1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/centralrepository/test/t_cenrep_defects.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2979 @@
1.4 +// Copyright (c) 2004-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 +//
1.18 +
1.19 +#include "t_cenrep_helper.h"
1.20 +#include <centralrepository.h>
1.21 +#include <e32property.h>
1.22 +#include <e32test.h>
1.23 +#include <f32file.h>
1.24 +#include <bautils.h>
1.25 +#include <cenrepnotifyhandler.h>
1.26 +
1.27 +#include "e32math.h"
1.28 +#include "srvparams.h"
1.29 +#include "srvreqs.h"
1.30 +#include "srvdefs.h"
1.31 +#include "transstate.h"
1.32 +#include "obsrvr_noc.h"
1.33 +#include "shrepos.h"
1.34 +#include "install.h"
1.35 +
1.36 +using namespace NCentralRepositoryConstants;
1.37 +
1.38 +RTest TheTest(_L("Central Repository Defect Tests"));
1.39 +
1.40 +_LIT( KCentralRepositoryServerName, "Centralrepositorysrv");
1.41 +
1.42 +const TUid KUidDEF060843LRepository1 = { 0x00000001 };
1.43 +const TUid KUidRep1 = { 0x00000100 };
1.44 +const TUid KUidDEF053500LTestRepository = { 0x00000102 };
1.45 +const TUid KUidDEF054368TestRepository = { 0x00000103 };
1.46 +const TUid KUidINC054688TestRepository = { 0x100058db };
1.47 +const TUid KUidDEF054632TestRepository = { 0x10054632 };
1.48 +const TUid KUidDEF054633TestRepository = { 0x10054633 };
1.49 +const TUid KUidLargeRepository = { 0xCCCCCC01 };
1.50 +const TUid KUidDEF055661TestRepository = { 0x10055661 };
1.51 +const TUid KUidINC056194TestRepository = { 0x00056194 };
1.52 +const TUid KUidDEF057778TestRepository = { 0x00057778 };
1.53 +const TUid KUidDEF057470TestRepository = { 0x10057470 };
1.54 +const TUid KUidDEF058900TestRepository = { 0x10058900 };
1.55 +const TUid KUidINC069013TestRepository = { 0x00000104 };
1.56 +const TUid KUidPDEF098500LRepository = { 0x10098500 };
1.57 +
1.58 +const TUint32 KRangeDeletePartialKey = 0x04010000 ;
1.59 +const TUint32 KDeleteKeyDoesntExist = 0x07000000 ;
1.60 +const TUint32 KDeleteForbidden = 0x03010000 ;
1.61 +const TUint32 KTransactionRangeDeletePartialKey = 0x02010000 ;
1.62 +const TUint32 KRangeDeleteMask = 0x0F0F0000 ;
1.63 +const TUint32 KNullKey = 0x00000000 ;
1.64 +
1.65 +const TUint32 KNotifyBannedKey = static_cast<TUint32>(KRequestPending) ;
1.66 +const TUint32 KNotificationKey1 = 0x80000101;
1.67 +const TUint32 KNotificationKey2 = 0x80000201;
1.68 +const TUint32 KNotificationKey3 = 0x80000301;
1.69 +const TUint32 KNotificationKey4 = 0x80000401;
1.70 +
1.71 +//
1.72 +// Repository A
1.73 +//
1.74 +
1.75 +const TUint32 KNewInt = 1000;
1.76 +const TInt KIntValue = 1234;
1.77 +
1.78 +
1.79 +// Definitions for test DEF116629L()
1.80 +// The structure to construct a TServerSetting object with a TInt value.
1.81 +struct ServerSettingStruct
1.82 + {
1.83 + TUint32 key;
1.84 + TUint32 meta;
1.85 + TInt value;
1.86 + };
1.87 +// The merge types to be tested
1.88 +const TMergeType KMergerTypes[] = {ETransactionMerge,ERestoreMerge, ESWIUpgradeMerge, ESWIDowngradeMerge, ERomFlash};
1.89 +
1.90 +
1.91 +///////////////////////////////////////////////////////////////////////////////////////
1.92 +///////////////////////////////////////////////////////////////////////////////////////
1.93 +//Test macroses and functions
1.94 +LOCAL_C void CheckL(TInt aValue, TInt aLine)
1.95 + {
1.96 + if(!aValue)
1.97 + {
1.98 + CleanupCDriveL();
1.99 + TheTest(EFalse, aLine);
1.100 + }
1.101 + }
1.102 +LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine)
1.103 + {
1.104 + if(aValue != aExpected)
1.105 + {
1.106 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.107 + CleanupCDriveL();
1.108 + TheTest(EFalse, aLine);
1.109 + }
1.110 + }
1.111 +
1.112 +#define TEST(arg) ::CheckL((arg), __LINE__)
1.113 +#define TEST2(aValue, aExpected) ::CheckL(aValue, aExpected, __LINE__)
1.114 +
1.115 +///////////////////////////////////////////////////////////////////////////////////////
1.116 +///////////////////////////////////////////////////////////////////////////////////////
1.117 +
1.118 +/**
1.119 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4015
1.120 +@SYMTestCaseDesc When having multiple connections to a particular repository, starting a
1.121 +transaction and then killing that connection, should not cause a reset.
1.122 +@SYMTestPriority High
1.123 +@SYMTestActions
1.124 + Essentially - this deals with multiple connections, the lack of cancelling a transaction,
1.125 + either by shutting the sub-session to the CR server directly (or by a crashing application
1.126 + where all open sub-sessions to CR from that application are closed) and the cache manager
1.127 + inside CR.
1.128 +
1.129 + Previously, CR's cache manager would reclaim repository memory regardless of the state
1.130 + of the repository (in transaction or not). However, if a repository is closed and its
1.131 + no longer an open repository (cache manager reclaimed the memory), it would not remove
1.132 + references to the sub-session for this repository in the transaction queue. Simply put,
1.133 + the sub-session's data would be deleted but there would still be references to that
1.134 + deleted data. When you established a new connection (any operation would cause this) you'd
1.135 + walk down an invalid pointer. Most of the time this would cause the server to crash.
1.136 +
1.137 + Now, if you're in an active transaction, the cache manager does not reclaim the data.
1.138 + Which means that there will always be valid references in the transaction queue.
1.139 +
1.140 + ThreadA CR CR Cache Manager
1.141 + Connection 1.
1.142 + CRepository::NewLC(X) ---------------> EInitialize
1.143 +
1.144 + Connection 2.
1.145 + CRepository::NewLC(X) ---------------> EInitialize
1.146 +
1.147 + Connection 2, Start Transaction
1.148 + StartTransaction ----------------> ETransactionStart
1.149 +
1.150 + Before
1.151 + ----------------------------------------------------------------------------------
1.152 + Wait 10 seconds
1.153 +
1.154 + <--------------------------- Evict(X)
1.155 +
1.156 + Connection 2. Close
1.157 + delete connection2 ------------------> EClose (would leave invalid references)
1.158 +
1.159 + Connection 1.
1.160 + GetInt ------------------> EGetInt (would attach to repository, derefence
1.161 + invalid pointer, CR would crash)
1.162 +
1.163 + -----------------------------------------------------------------------------------
1.164 + Now
1.165 +
1.166 + Wait 10 seconds
1.167 +
1.168 + Reschedule
1.169 + (CR cache manager sees that Repository X
1.170 + is in a transaction and just reschedules
1.171 + it)
1.172 + Connection 2. Close
1.173 + delete connection2 --------------------> EClose (memory is now available so it cancels
1.174 + the active transaction)
1.175 +
1.176 + GetInt --------------------> EGetInt (attaches to the open repository, all is
1.177 + fine)
1.178 + delete connection2 --------------------> EClose (repository X has no more observers so
1.179 + it is scheduled to have its memory reclaimed
1.180 + by CR cache manager)
1.181 +
1.182 +@SYMTestExpectedResults The test must not fail.
1.183 +@SYMDEF DEF111734
1.184 +*/
1.185 +
1.186 +LOCAL_C void DEF111734L()
1.187 + {
1.188 + /* first establish a connection. this is important because if there are no observers
1.189 + * on a repository, the repository's shared data is deleted directly */
1.190 + CRepository* rep;
1.191 + User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository));
1.192 +
1.193 + /* second establish a second connection. this will be used to start a transaction */
1.194 + CRepository* rep2;
1.195 + User::LeaveIfNull(rep2 = CRepository::NewLC(KUidDEF054368TestRepository));
1.196 +
1.197 + /* establish a transaction, this manipulates the transaction queue for this repository */
1.198 + rep2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.199 +
1.200 + /* now wait. this should be plenty of time to allow cache manager in CR to reclaim
1.201 + * the data for this repository */
1.202 + User::After(5050000 + 9500000);
1.203 +
1.204 + TInt i = 0;
1.205 + const TInt KInt1_InitialValue = 100;
1.206 + const TUint32 KInt1 = 0x1;
1.207 +
1.208 + /* destory the connection - this will cause a "close" operation in CR */
1.209 + CleanupStack::PopAndDestroy(rep2);
1.210 +
1.211 + /* attempt to reconnect to the repository. */
1.212 + TInt r = rep->Get(KInt1, i);
1.213 +
1.214 + /* if the fix is not in the build, then CR will crash.
1.215 + * Errcode will be KErrServerTerminated */
1.216 + TEST2(r, KErrNone);
1.217 +
1.218 + /* just for completion's sake, check the return value */
1.219 + TEST(i == KInt1_InitialValue);
1.220 +
1.221 + // Close repository
1.222 +
1.223 + CleanupStack::PopAndDestroy(rep);
1.224 + }
1.225 +
1.226 +
1.227 +LOCAL_C void DEF053500L()
1.228 + {
1.229 + CRepository* rep;
1.230 + // Open repository with hex key value setting
1.231 + User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF053500LTestRepository));
1.232 + // Close repository
1.233 + CleanupStack::PopAndDestroy(rep);
1.234 + }
1.235 +
1.236 +LOCAL_C void DEF054368L()
1.237 + {
1.238 + CRepository* rep;
1.239 + User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository));
1.240 +
1.241 + TInt i = 0;
1.242 + const TInt KInt1_InitialValue = 100;
1.243 + const TInt KInt2_InitialValue = 200;
1.244 + const TInt KInt3_InitialValue = -100;
1.245 + const TInt KInt4_InitialValue = -200;
1.246 + const TInt KInt5_InitialValue = 0xc8;
1.247 +
1.248 + const TUint32 KInt1 = 0x1;
1.249 + const TUint32 KInt2 = 0x2;
1.250 + const TUint32 KInt3 = 0x3;
1.251 + const TUint32 KInt4 = 0x4;
1.252 + const TUint32 KInt5 = 0x5;
1.253 +
1.254 + TInt r = rep->Get(KInt1, i);
1.255 + TEST2(r, KErrNone);
1.256 + TEST(i==KInt1_InitialValue);
1.257 +
1.258 + r = rep->Get(KInt2, i);
1.259 + TEST2(r, KErrNone);
1.260 + TEST(i==KInt2_InitialValue);
1.261 +
1.262 + r = rep->Get(KInt3, i);
1.263 + TEST2(r, KErrNone);
1.264 + TEST(i==KInt3_InitialValue);
1.265 +
1.266 + r = rep->Get(KInt4, i);
1.267 + TEST2(r, KErrNone);
1.268 + TEST(i==KInt4_InitialValue);
1.269 +
1.270 + r = rep->Get(KInt5, i);
1.271 + TEST2(r, KErrNone);
1.272 + TEST(i==KInt5_InitialValue);
1.273 +
1.274 + // Close repository
1.275 + CleanupStack::PopAndDestroy(rep);
1.276 + }
1.277 +
1.278 +LOCAL_C void DEF055680L()
1.279 + {
1.280 + CRepository* rep;
1.281 + // Open repository
1.282 + User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));
1.283 +
1.284 + // Find setting whose value the test doesn't have permission to look at
1.285 + RArray<TUint32> foundIds;
1.286 + TInt r = KErrNone;
1.287 + r = rep->FindL(0x810100, 0xFFFFFFFF, foundIds);
1.288 + TEST2(r, KErrNone);
1.289 + TEST2(foundIds.Count(), 1);
1.290 +
1.291 + TInt val;
1.292 + r = rep->Get(foundIds[0], val);
1.293 + TEST2(r, KErrPermissionDenied);
1.294 + foundIds.Reset();
1.295 +
1.296 + r = rep->Create(KNewInt, KIntValue);
1.297 + TEST2(r, KErrNone);
1.298 +
1.299 + //Reset repository to remove any changes made during this test
1.300 + r = rep->Reset();
1.301 + TEST2(r, KErrNone);
1.302 +
1.303 + // Close repository
1.304 + CleanupStack::PopAndDestroy(rep);
1.305 +
1.306 + }
1.307 +
1.308 +LOCAL_C void DEF054632L()
1.309 + {
1.310 + CRepository* rep;
1.311 +
1.312 + //----------Testing for correct default policy behaviour---------------
1.313 + /*---------------------10054632.txt------------------------------------
1.314 + [platsec]
1.315 + cap_rd=ReadDeviceData cap_wr=WriteDeviceData
1.316 + 0x3 0x4 cap_wr=NetworkServices
1.317 + [Main]
1.318 + 0x1 int 1 0 cap_rd=CommDD
1.319 + 0x2 int 2 1 cap_wr=CommDD
1.320 + 0x3 int 3 0
1.321 + 0x4 int 4 0
1.322 + 0x5 int 5 0 cap_rd=CommDD
1.323 + ---------------------------------------------------------------------*/
1.324 + User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054632TestRepository));
1.325 +
1.326 + //testing single policies
1.327 + TInt err=KErrNone;
1.328 + const TInt key_2=2;
1.329 + const TInt key_1=1;
1.330 + TInt value=0;
1.331 +
1.332 + err=rep->Get(key_2,value);
1.333 + TEST2(err,KErrNone);
1.334 +
1.335 + err=rep->Set(key_1,value);
1.336 + TEST2(err,KErrNone);
1.337 +
1.338 + //testing range policies
1.339 + const TInt key_3=3;
1.340 + err=rep->Get(key_3,value);
1.341 + TEST2(err,KErrNone);
1.342 +
1.343 + CleanupStack::PopAndDestroy(rep);
1.344 +
1.345 + //------Testing for correct policy behaviour with no default policies-----
1.346 + /*--------------------------10054633.txt----------------------------------
1.347 + [platsec]
1.348 + 0x3 0x4 cap_rd=CommDD
1.349 + [Main]
1.350 + 0x1 int 1 0 cap_rd=CommDD
1.351 + 0x2 int 2 1 cap_wr=CommDD
1.352 + 0x3 int 3 0
1.353 + 0x4 int 4 0
1.354 + ------------------------------------------------------------------------*/
1.355 + User::LeaveIfNull(rep=CRepository::NewLC(KUidDEF054633TestRepository));
1.356 +
1.357 + //testing single policies
1.358 + err=rep->Get(key_1,value);
1.359 + TEST2(err,KErrPermissionDenied);
1.360 + err=rep->Set(key_1,value);
1.361 + TEST2(err,KErrPermissionDenied);
1.362 +
1.363 + err=rep->Set(key_2,value);
1.364 + TEST2(err,KErrPermissionDenied);
1.365 + err=rep->Get(key_2,value);
1.366 + TEST2(err,KErrPermissionDenied);
1.367 +
1.368 + //testing range policies
1.369 + err=rep->Get(key_3,value);
1.370 + TEST2(err,KErrPermissionDenied);
1.371 + const TInt key_4=4;
1.372 + err=rep->Set(key_4,value);
1.373 + TEST2(err,KErrPermissionDenied);
1.374 + err=rep->Get(key_4,value);
1.375 + TEST2(err,KErrPermissionDenied);
1.376 +
1.377 + CleanupStack::PopAndDestroy(rep);
1.378 + }
1.379 +
1.380 +/**
1.381 +This test will be checking the robustness of the modified array structure
1.382 +for the single policies, range policies.
1.383 +*/
1.384 +LOCAL_C void INC054688L()
1.385 + {
1.386 + CRepository* rep;
1.387 + User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository));
1.388 +
1.389 + //--------------CHECKING THE SINGLE POLICIES ARRAY----------------------
1.390 + //The ini file has been structured so that the key will be equal to the
1.391 + //key value so we can test it using a loop.
1.392 + //and also to check some policy checking, we set all the even entries to
1.393 + //be non accessible due to insufficient capabilities
1.394 + //The key tested for the single policies are from 1 to 24
1.395 + const TInt KMaxKeyEntry=24;
1.396 + TInt err=KErrNone;
1.397 + TInt key_value=0;
1.398 + for (TInt i=1;i<=KMaxKeyEntry;i++)
1.399 + {
1.400 + err=rep->Get(i,key_value);
1.401 + //even entries alway not accessible due to insufficient caps
1.402 + if (i%2==0)
1.403 + TEST2(err,KErrPermissionDenied);
1.404 + else
1.405 + {
1.406 + TEST2(err,KErrNone);
1.407 + TEST2(i,key_value);
1.408 + }
1.409 + }
1.410 +
1.411 + //--------------CHECKING THE RANGE POLICIES ARRAY----------------------
1.412 + //The range policies in the [platsec] section are arranged in key pairs
1.413 + //e.g 25-26,27-28.For testing purpose, the odd pairs(e.g 25-26 is the
1.414 + //first pair) will require capabilities that the test lacks off hence
1.415 + //causing KErrPermissionDenied when trying to read those range.
1.416 + //The key tested for the arary policies are from 25-38 and the value
1.417 + //matches the key
1.418 +
1.419 + const TInt startRangeKey=25;
1.420 + const TInt KMaxRangeKey=38;
1.421 + TInt numberOfPairs=(KMaxRangeKey-startRangeKey+1)/2;
1.422 + TInt key_value1=0;
1.423 + TInt err1=KErrNone;
1.424 + for (TInt j=0;j<numberOfPairs;j++)
1.425 + {
1.426 + //Get first key of the pair
1.427 + err=rep->Get(startRangeKey+(2*j),key_value);
1.428 + //Get second key of the pair
1.429 + err1=rep->Get(startRangeKey+(2*j)+1,key_value1);
1.430 + //start from j=0(first pair)
1.431 + if ((j+1)%2==0)
1.432 + {
1.433 + TEST2(err,KErrNone);
1.434 + TEST2(err1,KErrNone);
1.435 + TEST2(startRangeKey+(2*j),key_value);
1.436 + TEST2(startRangeKey+(2*j)+1,key_value1);
1.437 + }
1.438 + //only odd pairs are non-accessible due to insufficient caps
1.439 + else
1.440 + {
1.441 + TEST2(err,KErrPermissionDenied);
1.442 + TEST2(err1,KErrPermissionDenied);
1.443 + }
1.444 + }
1.445 +
1.446 + //Before closing the repository, modify one of the key to see whether
1.447 + //the policy array behaves similarly after a rewrite of the ini file
1.448 + const TInt keyToChange=3;
1.449 + const TInt modifiedValue=3;
1.450 + err=rep->Set(keyToChange,modifiedValue);
1.451 + TEST2(err,KErrNone);
1.452 +
1.453 + // Close repository
1.454 + CleanupStack::PopAndDestroy(rep);
1.455 + User::After(KGeneralDelay);
1.456 +
1.457 + //Reopen the repository again after that minor update which will cause
1.458 + //all the entry in the ini file to be reversed
1.459 + User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository));
1.460 +
1.461 + //---------RECHECKING THE POLICY ARRAY AFTER UPDATE--------------------
1.462 + for (TInt i=1;i<=KMaxKeyEntry;i++)
1.463 + {
1.464 + err=rep->Get(i,key_value);
1.465 + //even entries alway not accessible due to insufficient caps
1.466 + if (i%2==0)
1.467 + TEST2(err,KErrPermissionDenied);
1.468 + else
1.469 + {
1.470 + TEST2(err,KErrNone);
1.471 + TEST2(i,key_value);
1.472 + }
1.473 + }
1.474 +
1.475 +
1.476 + //---------RECHECKING THE RANGE POLICY ARRAY AFTER UPDATE-------------
1.477 + for (TInt j=0;j<numberOfPairs;j++)
1.478 + {
1.479 + //Get first key of the pair
1.480 + err=rep->Get(startRangeKey+(2*j),key_value);
1.481 + //Get second key of the pair
1.482 + err1=rep->Get(startRangeKey+(2*j)+1,key_value1);
1.483 + //start from j=0(first pair)
1.484 + if ((j+1)%2==0)
1.485 + {
1.486 + TEST2(err,KErrNone);
1.487 + TEST2(err1,KErrNone);
1.488 + TEST2(startRangeKey+(2*j),key_value);
1.489 + TEST2(startRangeKey+(2*j)+1,key_value1);
1.490 + }
1.491 + //only odd pairs are non-accessible due to insufficient caps
1.492 + else
1.493 + {
1.494 + TEST2(err,KErrPermissionDenied);
1.495 + TEST2(err1,KErrPermissionDenied);
1.496 + }
1.497 + }
1.498 +
1.499 + CleanupStack::PopAndDestroy(rep);
1.500 + }
1.501 +
1.502 +LOCAL_C void DEF055661L()
1.503 + {
1.504 + /*--------------------10055661.txt----------------------------------------
1.505 + [platsec]
1.506 + cap_rd=ReadDeviceData cap_wr=AlwaysFail
1.507 + 0x3 0x4 cap_wr=NetworkServices
1.508 + [Main]
1.509 + 0x1 int 1 0 cap_rd=AlwaysPass
1.510 + 0x2 int 2 1 cap_rd=AlwaysFail
1.511 + 0x3 int 3 0
1.512 + 0x4 int 4 0 cap_rd=AlwaysFail
1.513 + 0x5 int 5 0 cap_wr=AlwaysPass
1.514 + -------------------------------------------------------------------------*/
1.515 + CRepository* rep;
1.516 + User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF055661TestRepository));
1.517 +
1.518 + TInt err=KErrNone;
1.519 + TInt keyValue=0;
1.520 +
1.521 + //Key 1
1.522 + err=rep->Get(1,keyValue);
1.523 + TEST2(err,KErrNone);
1.524 + TEST2(keyValue,1);
1.525 + err=rep->Set(1,keyValue);
1.526 + TEST2(err,KErrPermissionDenied);
1.527 +
1.528 + //Key 2
1.529 + err=rep->Get(2,keyValue);
1.530 + TEST2(err,KErrPermissionDenied);
1.531 + err=rep->Set(2,keyValue);
1.532 + TEST2(err,KErrPermissionDenied);
1.533 +
1.534 + //Key 3
1.535 + err=rep->Get(3,keyValue);
1.536 + TEST2(err,KErrNone);
1.537 + TEST2(keyValue,3);
1.538 + err=rep->Set(3,keyValue);
1.539 + TEST2(err,KErrPermissionDenied);
1.540 +
1.541 + //Key 4
1.542 + err=rep->Get(4,keyValue);
1.543 + TEST2(err,KErrPermissionDenied);
1.544 + err=rep->Set(4,keyValue);
1.545 + TEST2(err,KErrPermissionDenied);
1.546 +
1.547 + //Key 5
1.548 + err=rep->Get(5,keyValue);
1.549 + TEST2(err,KErrNone);
1.550 + err=rep->Set(5,keyValue);
1.551 + TEST2(err,KErrNone);
1.552 +
1.553 + CleanupStack::PopAndDestroy(rep);
1.554 + }
1.555 +
1.556 +LOCAL_C void DEF055267L()
1.557 + {
1.558 + CRepository* rep;
1.559 + // Open repository
1.560 + User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));
1.561 +
1.562 + TInt r;
1.563 + TUint32 errorId;
1.564 + // The following loop creates enough settings to blow the server heap
1.565 + // when it's 1 M. If it passes it proves that the server heap is > 1M
1.566 + // Increasing the server heap allows the messaging test to pass
1.567 + _LIT(KString, "Long test string !!!!!!!!!!!");
1.568 + const TInt KNumTransactions=25;
1.569 + const TInt KNumSettingsInTrans=100;
1.570 + for(TInt numTransactions=0; numTransactions<KNumTransactions;numTransactions++)
1.571 + {
1.572 + r = rep->StartTransaction(CRepository::EReadWriteTransaction);
1.573 + TEST2(r, KErrNone);
1.574 + for(TInt numSettingsInTrans=0; numSettingsInTrans<KNumSettingsInTrans; numSettingsInTrans++)
1.575 + {
1.576 + r = rep->Create((numTransactions*KNumSettingsInTrans)+numSettingsInTrans, KString);
1.577 + TEST2(r, KErrNone);
1.578 + }
1.579 + r = rep->CommitTransaction(errorId);
1.580 + TEST2(r, KErrNone);
1.581 + }
1.582 +
1.583 + //Reset repository to remove any changes made during this test
1.584 + r = rep->Reset();
1.585 + TEST2(r, KErrNone);
1.586 +
1.587 + // Close repository
1.588 + CleanupStack::PopAndDestroy(rep);
1.589 + }
1.590 +
1.591 +LOCAL_C void INC056194L()
1.592 + {
1.593 + CRepository* repository;
1.594 + // Open repository
1.595 + User::LeaveIfNull(repository = CRepository::NewLC(KUidINC056194TestRepository));
1.596 +
1.597 + const TUint32 KInt1 = 1;
1.598 + TRequestStatus intStatus;
1.599 +
1.600 + TInt r = repository->NotifyRequest(KInt1, intStatus);
1.601 + TEST2(r, KErrNone);
1.602 + r = repository->NotifyCancel(KInt1);
1.603 + TEST2(r, KErrNone);
1.604 + User::WaitForAnyRequest();
1.605 + TEST(intStatus==KUnspecifiedKey);
1.606 +
1.607 + r = repository->NotifyRequest(KInt1, intStatus);
1.608 + TEST2(r, KErrNone);
1.609 + r = repository->NotifyCancelAll();
1.610 + TEST2(r, KErrNone);
1.611 + User::WaitForAnyRequest();
1.612 + TEST(intStatus==KUnspecifiedKey);
1.613 +
1.614 + r = repository->NotifyRequest(0, KInt1, intStatus);
1.615 + TEST2(r, KErrNone);
1.616 + r = repository->NotifyCancel(0, KInt1);
1.617 + TEST2(r, KErrNone);
1.618 + User::WaitForAnyRequest();
1.619 + TEST(intStatus==KUnspecifiedKey);
1.620 +
1.621 + RThread thisThread;
1.622 + TEST(thisThread.RequestCount()==0);
1.623 +
1.624 + // Close repository
1.625 + CleanupStack::PopAndDestroy(repository);
1.626 + }
1.627 +
1.628 +LOCAL_C void DEF057145L()
1.629 + {
1.630 + TInt err=KErrNone;
1.631 + const TUid testUid={0x10057145};
1.632 + RArray<TUint32> idArray;
1.633 + CRepository* repository;
1.634 + User::LeaveIfNull(repository = CRepository::NewLC(testUid));
1.635 +
1.636 + //Start Transaction
1.637 + err=repository->StartTransaction(CRepository::EReadWriteTransaction);
1.638 + TEST2(err,KErrNone);
1.639 +
1.640 + //Before creating new entries get the number of persistent settings
1.641 + err=repository->FindL(0,0xFFFFF000,idArray);
1.642 + TEST2(err,KErrNone);
1.643 + TInt persistentSettingsCount=idArray.Count();
1.644 + idArray.Close();
1.645 +
1.646 + //Try creating new entries during transaction between the two extreme points
1.647 + //ROM persistent file has low key of 1 and high key of 201
1.648 + //We try creating new entries in between during transaction
1.649 + for (TInt i=100;i<150;i++)
1.650 + {
1.651 + err=repository->Create(i,i);
1.652 + TEST2(err,KErrNone);
1.653 + }
1.654 +
1.655 + //Now check the merge with the persistent settings is fine by checking
1.656 + //the array count after the merge.
1.657 + err=repository->FindL(0x000,0xFFFFF000,idArray);
1.658 + TEST2(err,KErrNone);
1.659 + TEST(idArray.Count()==(persistentSettingsCount+50));
1.660 + idArray.Close();
1.661 +
1.662 + TUint32 errId;
1.663 + err=repository->CommitTransaction(errId);
1.664 + TEST2(err,KErrNone);
1.665 +
1.666 + idArray.Close();
1.667 + CleanupStack::PopAndDestroy(repository);
1.668 + }
1.669 +
1.670 +
1.671 +LOCAL_C void DEF057778L()
1.672 + {
1.673 + TInt r;
1.674 + CRepository* repository;
1.675 + // Open repository
1.676 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057778TestRepository));
1.677 +
1.678 + const TUint32 KInt14=14;
1.679 + const TInt KInt14NewValue=0;
1.680 +
1.681 + r=repository->Set(KInt14,KInt14NewValue);
1.682 + TEST2(r, KErrNone);
1.683 +
1.684 + // Reset setting that has a single policy
1.685 + r=repository->Reset(KInt14);
1.686 + TEST2(r, KErrNone);
1.687 +
1.688 + // Attempt to access and write setting
1.689 + r=repository->Set(KInt14,KInt14NewValue);
1.690 + TEST2(r, KErrNone);
1.691 +
1.692 + // Reset entire repository
1.693 + r=repository->Reset();
1.694 + TEST2(r, KErrNone);
1.695 +
1.696 + // Attempt to access and write setting
1.697 + r=repository->Set(KInt14,KInt14NewValue);
1.698 + TEST2(r, KErrNone);
1.699 +
1.700 + // Reset entire repository
1.701 + r=repository->Reset();
1.702 + TEST2(r, KErrNone);
1.703 +
1.704 + // Close repository
1.705 + CleanupStack::PopAndDestroy(repository);
1.706 + }
1.707 +
1.708 +
1.709 +LOCAL_C void DEF057999L()
1.710 + {
1.711 +
1.712 + TInt err=KErrNone;
1.713 + TInt retValue=0;
1.714 + const TUid testUid={0x10057145};
1.715 + RArray<TUint32> idArray;
1.716 +
1.717 + CRepository* repository;
1.718 + User::LeaveIfNull(repository = CRepository::NewLC(testUid));
1.719 +
1.720 + //--------------Start Transaction------------------------------------
1.721 + err=repository->StartTransaction(CRepository::EReadWriteTransaction);
1.722 + TEST2(err,KErrNone);
1.723 +
1.724 + //--------------Create follow by delete-----------------------------
1.725 + err=repository->Create(3400,3400);
1.726 + TEST2(err,KErrNone);
1.727 + err=repository->Delete(3400);
1.728 + TEST2(err,KErrNone);
1.729 + err=repository->Delete(3400);
1.730 + TEST2(err,KErrNotFound);
1.731 +
1.732 + //--------------Deleting existing romkey-----------------------------
1.733 + err=repository->Delete(200);
1.734 + TEST2(err,KErrNone);
1.735 +
1.736 + err=repository->FindL(200,0xFFFFFFFF,idArray);
1.737 + TEST2(err,KErrNotFound);
1.738 +
1.739 + //--------------Commit Transaction------------------------------------
1.740 + TUint32 errId;
1.741 + err=repository->CommitTransaction(errId);
1.742 + TEST2(err,KErrNone);
1.743 +
1.744 + idArray.Close();
1.745 + CleanupStack::PopAndDestroy(repository);
1.746 +
1.747 + //--------------Reopen and check the deleted keys are gone-------------
1.748 + User::LeaveIfNull(repository = CRepository::NewLC(testUid));
1.749 +
1.750 + //Check for the key created and deleted during transaction
1.751 + err=repository->FindL(3400,0xFFFFFFFF,idArray);
1.752 + TEST2(err,KErrNotFound);
1.753 +
1.754 + //Check for the rom key deleted during transaction
1.755 + err=repository->Get(200,retValue);
1.756 + TEST2(err,KErrNotFound);
1.757 +
1.758 + //--------------Start Transaction------------------------------------
1.759 + err=repository->StartTransaction(CRepository::EReadWriteTransaction);
1.760 + TEST2(err,KErrNone);
1.761 +
1.762 + //--------------Delete follow by create-----------------------------
1.763 + err=repository->Delete(201);
1.764 + TEST2(err,KErrNone);
1.765 + err=repository->Create(201, 201);
1.766 + TEST2(err,KErrNone);
1.767 +
1.768 + //--------------Commit Transaction------------------------------------
1.769 + err=repository->CommitTransaction(errId);
1.770 + TEST2(err,KErrNone);
1.771 +
1.772 + err=repository->Get(201,retValue);
1.773 + TEST2(err,KErrNone);
1.774 + TEST2(retValue, 201);
1.775 +
1.776 + CleanupStack::PopAndDestroy(repository);
1.777 + }
1.778 +
1.779 +LOCAL_C void DEF057522L()
1.780 + {
1.781 + TInt r=KErrNone;
1.782 + CRepository* repository;
1.783 + TUid testUidRepository={0x10057522};
1.784 +
1.785 + //Opening a repository with Max number of capabilities supported should not return KErrCorrupt
1.786 + User::LeaveIfNull(repository = CRepository::NewLC(testUidRepository));
1.787 +
1.788 + //Test reading some of the settings with the max capabilities defined
1.789 + TInt retVal=0;
1.790 + r=repository->Get(17,retVal);
1.791 + TEST2(r,KErrNone);
1.792 + r=repository->Set(17,retVal);
1.793 + TEST2(r,KErrNone);
1.794 +
1.795 + r=repository->Get(18,retVal);
1.796 + TEST2(r,KErrPermissionDenied);
1.797 + r=repository->Set(18,retVal);
1.798 + TEST2(r,KErrNone);
1.799 +
1.800 + //Test that AlwaysPass and AlwaysFail behave as expected when not followed by sid
1.801 + r=repository->Get(21,retVal);
1.802 + TEST2(r,KErrPermissionDenied);
1.803 + r=repository->Set(21,retVal);
1.804 + TEST2(r,KErrPermissionDenied);
1.805 + r=repository->Get(22,retVal);
1.806 + TEST2(r,KErrNone);
1.807 + r=repository->Set(22,retVal);
1.808 + TEST2(r,KErrNone);
1.809 +
1.810 +
1.811 + //Test that AlwaysPass and AlwaysFail behave as expected when followed by sid
1.812 + r=repository->Get(19,retVal);
1.813 + TEST2(r,KErrPermissionDenied);
1.814 + r=repository->Set(19,retVal);
1.815 + TEST2(r,KErrNone);
1.816 +
1.817 + //Additional test cases
1.818 + //Test single policies with max 3 caps for both read and write
1.819 + r=repository->Get(28,retVal);
1.820 + TEST2(r,KErrPermissionDenied);
1.821 + r=repository->Set(28,retVal);
1.822 + TEST2(r,KErrNone);
1.823 +
1.824 + //Test single policies with max 7 caps for both read and write
1.825 + r=repository->Get(33,retVal);
1.826 + TEST2(r,KErrPermissionDenied);
1.827 + r=repository->Set(33,retVal);
1.828 + TEST2(r,KErrPermissionDenied);
1.829 +
1.830 + //Test range policies with max 3 caps when followed by sid
1.831 + r=repository->Get(201,retVal);
1.832 + TEST2(r,KErrPermissionDenied);
1.833 + r=repository->Set(201,retVal);
1.834 + TEST2(r,KErrNone);
1.835 +
1.836 + //Test range policies with max 7 caps not with sid
1.837 + r=repository->Get(300,retVal);
1.838 + TEST2(r,KErrPermissionDenied);
1.839 + r=repository->Set(300,retVal);
1.840 + TEST2(r,KErrPermissionDenied);
1.841 +
1.842 + //Test behaviour when single policies are specified with just sid
1.843 + r=repository->Get(400,retVal);
1.844 + TEST2(r,KErrNone);
1.845 + r=repository->Set(400,retVal);
1.846 + TEST2(r,KErrPermissionDenied); // default read cap for sid 0 is AlwaysFail
1.847 +
1.848 + r=repository->Get(401,retVal);
1.849 + TEST2(r,KErrNone); // default write cap for sid 0 is AlwaysPass
1.850 + r=repository->Set(401,retVal);
1.851 + TEST2(r,KErrNone);
1.852 +
1.853 + //Test that default policies are picked up when no policies are specified
1.854 + r=repository->Get(500,retVal);
1.855 + TEST2(r,KErrNone);
1.856 +
1.857 + r=repository->Set(500,retVal);
1.858 + TEST2(r,KErrPermissionDenied);
1.859 +
1.860 + CleanupStack::PopAndDestroy(repository);
1.861 + }
1.862 +
1.863 +LOCAL_C void DEF057470L()
1.864 + {
1.865 +
1.866 + TInt r=KErrNone;
1.867 + TUint32 errId=0;
1.868 + CRepository* repository;
1.869 +
1.870 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository));
1.871 +
1.872 + //-------------- 1. Simple Range Delete Operation-----------------------------
1.873 + // Confirm that keys exist
1.874 + RArray<TUint32> foundIds;
1.875 + r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);
1.876 + TEST2(r, KErrNone);
1.877 + TEST(foundIds.Count()==5);
1.878 + foundIds.Reset();
1.879 + // Delete a set of keys
1.880 + r = repository->Delete(KRangeDeletePartialKey, KRangeDeleteMask, errId) ;
1.881 + TEST2(r, KErrNone);
1.882 + // Confirm that deleted keys do not exist
1.883 + r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);
1.884 + TEST2(r, KErrNotFound);
1.885 + TEST(foundIds.Count()==0);
1.886 + foundIds.Reset();
1.887 + CleanupStack::PopAndDestroy(repository);
1.888 + // Try to find keys again just to double check whether the changes have persisted
1.889 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository));
1.890 + r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);
1.891 + TEST2(r, KErrNotFound);
1.892 + TEST(foundIds.Count()==0);
1.893 + foundIds.Reset();
1.894 +
1.895 +
1.896 + //--------------- 2. Range Delete Operation where keys don't exist--------------
1.897 + // Confirm that keys don't exist.
1.898 + r = repository->FindL(KDeleteKeyDoesntExist, KRangeDeleteMask, foundIds);
1.899 + TEST2(r, KErrNotFound);
1.900 + TEST(foundIds.Count()==0);
1.901 + foundIds.Reset();
1.902 + // Attempt delete and check result
1.903 + r = repository->Delete(KDeleteKeyDoesntExist, KRangeDeleteMask, errId) ;
1.904 + TEST2(r, KErrNotFound);
1.905 + errId &= KRangeDeleteMask ;
1.906 + TEST2(errId, KDeleteKeyDoesntExist) ;
1.907 +
1.908 +
1.909 + //-------3. Range Delete Operation where client doesn't have write capabilities for key range.----
1.910 + // Attempt delete and check result
1.911 + r = repository->Delete(KDeleteForbidden, KRangeDeleteMask, errId) ;
1.912 + TEST2(r, KErrPermissionDenied);
1.913 + errId &= KRangeDeleteMask ;
1.914 + TEST2(errId, KDeleteForbidden) ;
1.915 + // Close repository
1.916 + CleanupStack::PopAndDestroy(repository);
1.917 +
1.918 + //------ 4. Range Delete Operation which deletes all the keys and Resets the entire repository back its original state.
1.919 + TInt numberOfIds;
1.920 + User::LeaveIfNull(repository = CRepository::NewLC(KUidLargeRepository));
1.921 + // Find how many keys are originally present
1.922 + r = repository->FindL(KNullKey, KNullKey, foundIds);
1.923 + TEST2(r, KErrNone);
1.924 + numberOfIds = foundIds.Count();
1.925 + TEST(foundIds.Count()!=0);
1.926 + foundIds.Reset();
1.927 + // Range delete all the keys in the repository
1.928 + r = repository->Delete(KNullKey, KNullKey, errId);
1.929 + TEST2(r, KErrNone);
1.930 + // Check all the keys have been deleted from cache
1.931 + r = repository->FindL(KNullKey, KNullKey, foundIds);
1.932 + TEST2(r, KErrNotFound);
1.933 + TEST(foundIds.Count()==0);
1.934 + foundIds.Reset();
1.935 + // Close and re-open the repository to check if the deleted keys have persisted.
1.936 + CleanupStack::PopAndDestroy(repository);
1.937 + // Existance of caching functionality invalidates some tests and
1.938 + // makes them fail, so kill the server to force clearing the cache
1.939 + r = KillProcess(KCentralRepositoryServerName);
1.940 + TEST2(r,KErrNone);
1.941 + User::LeaveIfNull(repository = CRepository::NewLC(KUidLargeRepository));
1.942 + // Check all the deleted keys have persisted.
1.943 + r = repository->FindL(KNullKey, KNullKey, foundIds);
1.944 + TEST2(r, KErrNotFound);
1.945 + TEST(foundIds.Count()==0);
1.946 + foundIds.Reset();
1.947 + // Reset repository back to its original state from ROM
1.948 + r = repository->Reset();
1.949 + TEST2(r, KErrNone);
1.950 + // Check that number of keys is same as when we started.
1.951 + r = repository->FindL(KNullKey, KNullKey, foundIds);
1.952 + TEST2(r, KErrNone);
1.953 + TEST(foundIds.Count()==numberOfIds);
1.954 + foundIds.Reset();
1.955 + // Close the repository
1.956 + CleanupStack::PopAndDestroy(repository);
1.957 +
1.958 + //**********************Delete Range within Transacrions**********************
1.959 + //--------- 5. Range Delete within a transaction where key's don't exist.------------
1.960 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository));
1.961 + // Begin read write transaction.
1.962 + r = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.963 + TEST2(r, KErrNone);
1.964 + r = TransactionState(repository);
1.965 + TEST2(r, EReadWriteTransaction);
1.966 + r = repository->Delete(KDeleteKeyDoesntExist, KRangeDeleteMask, errId) ;
1.967 + TEST2(r, KErrNotFound);
1.968 + // Check that transaction hasn't failed.
1.969 + r = TransactionState(repository);
1.970 + TEST2(r, EReadWriteTransaction);
1.971 + // Fail transaction.
1.972 + repository->FailTransaction();
1.973 + r = TransactionState(repository);
1.974 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.975 + repository->RollbackTransaction();
1.976 + r = TransactionState(repository);
1.977 + TEST2(r, ENoTransaction);
1.978 +
1.979 +
1.980 + //---------- 6. Range delete within a transaction where client doesn't have capabilities to write to key range.
1.981 + // Begin read write transaction.
1.982 + r = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.983 + TEST2(r, KErrNone);
1.984 + r = repository->Delete(KDeleteForbidden, KRangeDeleteMask, errId) ;
1.985 + TEST2(r, KErrPermissionDenied);
1.986 + errId &= KRangeDeleteMask ;
1.987 + TEST2(errId, KDeleteForbidden) ;
1.988 + // check that transaction has failed.
1.989 + r = TransactionState(repository);
1.990 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.991 + // Rollback the failed transaction.
1.992 + repository->RollbackTransaction();
1.993 + r = TransactionState(repository);
1.994 + TEST2(r, ENoTransaction);
1.995 +
1.996 +
1.997 + //---------- 7. Range delete while not in transaction fails other session's transaction with KErrLocked.
1.998 + // Open another repository
1.999 + CRepository* repository2;
1.1000 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidDEF057470TestRepository));
1.1001 + // Begin read write transaction
1.1002 + r = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.1003 + TEST2(r, KErrNone);
1.1004 + r = TransactionState(repository);
1.1005 + TEST2(r, EReadWriteTransaction);
1.1006 + // Delete keys in the first session.
1.1007 + r = repository->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ;
1.1008 + TEST2(r, KErrNone);
1.1009 + // Delete keys in the second session.
1.1010 + r = repository2->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ;
1.1011 + TEST2(r, KErrNone);
1.1012 + // first session's transaction should have failed with KErrLocked
1.1013 + TInt state = TransactionState(repository);
1.1014 + TEST2(state, EReadWriteTransaction | EFailedBit);
1.1015 + // Commit transaction should report failure reason:
1.1016 + TUint32 keyInfo;
1.1017 + r = repository->CommitTransaction(keyInfo);
1.1018 + TEST2(r, KErrLocked);
1.1019 + TEST(keyInfo == KUnspecifiedKey);
1.1020 + r = TransactionState(repository);
1.1021 + TEST2(r, ENoTransaction);
1.1022 + // Close the repositories
1.1023 + CleanupStack::PopAndDestroy(repository2);
1.1024 +
1.1025 +
1.1026 + //----------- 8. Range Delete within a Transaction and Commit.-----------------------
1.1027 + //Before doing this we need to reset from the ROM first to restore the deleted keys in
1.1028 + //non transaction test earlier
1.1029 + r=repository->Reset();
1.1030 + TEST2(r,KErrNone);
1.1031 + r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds);
1.1032 + TEST2(r,KErrNone);
1.1033 + TEST(foundIds.Count()==5);
1.1034 + foundIds.Reset();
1.1035 + // Begin read write transaction
1.1036 + r = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.1037 + TEST2(r, KErrNone);
1.1038 + r = repository->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ;
1.1039 + TEST2(r, KErrNone);
1.1040 + // Commit transaction
1.1041 + r = repository->CommitTransaction(errId);
1.1042 + TEST2(r, KErrNone);
1.1043 + //The number of keys changed should be equal to the number of keys deleted
1.1044 + TEST(errId==5);
1.1045 +
1.1046 + //Reset repository to remove any changes made during this test
1.1047 + r=repository->Reset();
1.1048 + TEST2(r, KErrNone);
1.1049 +
1.1050 + // Close the repositories
1.1051 + CleanupStack::PopAndDestroy(repository);
1.1052 + }
1.1053 +
1.1054 +LOCAL_C void INC058229L()
1.1055 + {
1.1056 + RFs fs;
1.1057 + User::LeaveIfError(fs.Connect());
1.1058 + CleanupClosePushL(fs);
1.1059 +
1.1060 + CFileMan* fm = CFileMan::NewL(fs);
1.1061 + CleanupStack::PushL(fm);
1.1062 +
1.1063 + // Open repository to ensure server is running
1.1064 + CRepository* rep;
1.1065 + User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));
1.1066 + // Close repository
1.1067 + CleanupStack::PopAndDestroy(rep);
1.1068 +
1.1069 + // Remove install dir
1.1070 + TInt r = fm->RmDir(KCInstallDir);
1.1071 + if(r!=KErrNone && r!=KErrNotFound && r!=KErrPathNotFound)
1.1072 + User::Leave(r);
1.1073 + // Wait so that watcher will see directory is gone
1.1074 + User::After(KGeneralDelay);
1.1075 +
1.1076 + // Kill server so that next test will reconnect and recreate resources
1.1077 + r=KillProcess(KCentralRepositoryServerName);
1.1078 + TEST2(r,KErrNone);
1.1079 +
1.1080 + // Open repository to ensure directories are restored
1.1081 + User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));
1.1082 + // Close repository
1.1083 + CleanupStack::PopAndDestroy(3); // rep, fs, fm
1.1084 + }
1.1085 +
1.1086 +LOCAL_C void DEF058900L()
1.1087 + {
1.1088 +
1.1089 + CRepository* repository;
1.1090 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF058900TestRepository));
1.1091 + TRequestStatus intStatus;
1.1092 + RThread thisThread;
1.1093 +
1.1094 + //
1.1095 + // Basic notification to test notification for one banned key
1.1096 + //
1.1097 + TInt r = repository->NotifyRequest(KNotifyBannedKey, intStatus);
1.1098 + TEST2(r, KErrNone);
1.1099 + TEST(intStatus == KRequestPending);
1.1100 +
1.1101 + // First change to setting should cause notification
1.1102 + r = repository->Set(KNotifyBannedKey, 100);
1.1103 + TEST2(r, KErrNone);
1.1104 + User::WaitForAnyRequest();
1.1105 + TEST(intStatus==KUnspecifiedKey);
1.1106 +
1.1107 + //
1.1108 + // Group notification to test notification when the banned key is in a range
1.1109 + //
1.1110 + r = repository->NotifyRequest(KNullKey, KNullKey, intStatus);
1.1111 + TEST2(r, KErrNone);
1.1112 +
1.1113 + r = repository->Set(KNotifyBannedKey, 50);
1.1114 + TEST2(r, KErrNone);
1.1115 + User::WaitForAnyRequest();
1.1116 + TEST(intStatus==KUnspecifiedKey);
1.1117 + TEST(thisThread.RequestCount()==0);
1.1118 +
1.1119 + //
1.1120 + // Group notification to test notification when many keys including the banned key change
1.1121 + // i.e. a repository wide reset
1.1122 + //
1.1123 + // First change values for alot of the keys before a reset.
1.1124 + r = repository->Set(KNotificationKey1, 80);
1.1125 + TEST2(r, KErrNone);
1.1126 + r = repository->Set(KNotifyBannedKey, 50);
1.1127 + TEST2(r, KErrNone);
1.1128 + r = repository->Set(KNotificationKey2, 70);
1.1129 + TEST2(r, KErrNone);
1.1130 + r = repository->Set(KNotificationKey3, 60);
1.1131 + TEST2(r, KErrNone);
1.1132 + r = repository->Set(KNotificationKey4, 30);
1.1133 + TEST2(r, KErrNone);
1.1134 +
1.1135 + r = repository->NotifyRequest(KNullKey, KNullKey, intStatus); // Request notification
1.1136 + // for all keys in repository.
1.1137 + TEST2(r, KErrNone);
1.1138 +
1.1139 + //Reset the whole repository to original settings
1.1140 + r = repository->Reset();
1.1141 + TEST2(r, KErrNone);
1.1142 +
1.1143 + User::WaitForAnyRequest();
1.1144 + TEST(intStatus==KUnspecifiedKey);
1.1145 + TEST(thisThread.RequestCount()==0);
1.1146 +
1.1147 +
1.1148 + CleanupStack::PopAndDestroy(repository);
1.1149 + }
1.1150 +
1.1151 +LOCAL_C void DEF061087L()
1.1152 + {
1.1153 + TInt r=KErrNone;
1.1154 + TUid testUid={0x10061087};
1.1155 + CRepository* repository;
1.1156 + User::LeaveIfNull(repository = CRepository::NewLC(testUid));
1.1157 +
1.1158 + /*--------------Scenario 1---------------------
1.1159 + 100 300 cap_wr=ReadDeviceData
1.1160 + 100 200 cap_wr=TCB */
1.1161 + r=repository->Create(150,100);
1.1162 + TEST2(r,KErrPermissionDenied);
1.1163 + r=repository->Create(201,201);
1.1164 + TEST2(r,KErrNone);
1.1165 +
1.1166 + /*--------------Scenario 2---------------------
1.1167 + 400 500 cap_wr=ReadDeviceData
1.1168 + 400 500 cap_wr=TCB */
1.1169 + r=repository->Create(500,100);
1.1170 + TEST2(r,KErrPermissionDenied);
1.1171 +
1.1172 + /*--------------Scenario 3---------------------
1.1173 + 0x600 0x700 cap_wr=ReadDeviceData
1.1174 + # Odd entry from 600-700
1.1175 + 0x601 mask=0xF01 cap_wr=TCB*/
1.1176 + r=repository->Create(0x601,601);
1.1177 + TEST2(r,KErrPermissionDenied);
1.1178 + r=repository->Create(0x657,647);
1.1179 + TEST2(r,KErrPermissionDenied);
1.1180 + //0x602 will be even so it will check agains the next matched range policies
1.1181 + //which is 0x600 0x700 cap_wr=ReadDeviceData
1.1182 + r=repository->Create(0x602,600);
1.1183 + TEST2(r,KErrNone);
1.1184 +
1.1185 + /*--------------Scenario 4---------------------
1.1186 + # protected data
1.1187 + 0x00000100 mask=0x00000100 cap_wr=NetworkControl
1.1188 + # private data
1.1189 + 0x000000F0 mask=0x00000080 cap_rd=ReadDeviceData */
1.1190 + r=repository->Create(0x01000100,123);
1.1191 + TEST2(r,KErrPermissionDenied);
1.1192 + r=repository->Create(0x03450700,123);
1.1193 + TEST2(r,KErrPermissionDenied);
1.1194 + r=repository->Create(0x00450080,123);
1.1195 + TEST2(r,KErrNone);
1.1196 + r=repository->Create(0x06450081,123);
1.1197 + TEST2(r,KErrNone);
1.1198 +
1.1199 +
1.1200 + CleanupStack::PopAndDestroy(repository);
1.1201 + }
1.1202 +
1.1203 +
1.1204 +LOCAL_C void DEF060843L()
1.1205 + {
1.1206 + CRepository* repository;
1.1207 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
1.1208 +
1.1209 + _LIT8(KString12_InitialValue, "string");
1.1210 + TPtrC8 p8(KString12_InitialValue);
1.1211 + TInt len8 = p8.Length();
1.1212 +
1.1213 + _LIT(KString11_InitialValue, "string");
1.1214 + TPtrC p16(KString11_InitialValue);
1.1215 + TInt len16 = p16.Length();
1.1216 +
1.1217 + //setting ids in a test repository
1.1218 + const TUint32 KReal1 = 2;
1.1219 + const TUint32 KString11 = 11;
1.1220 + const TUint32 KString12 = 12;
1.1221 +
1.1222 + TInt r;
1.1223 + TInt i(0);
1.1224 +
1.1225 + TBuf<15> str;
1.1226 + TInt strLen;
1.1227 +
1.1228 + TBuf8<15> str8;
1.1229 + TInt strLen8;
1.1230 +
1.1231 + //================read real using int ========================
1.1232 + r = repository->Get(KReal1, i);
1.1233 + TEST2(r, KErrArgument);
1.1234 + TEST(i==0);
1.1235 +
1.1236 + //================read TDes16 using TDes8=====================
1.1237 + r = repository->Get(KString11, str8);
1.1238 + TEST2(r, KErrNone);
1.1239 +
1.1240 + //8-bit descriptor holding the same data as 16-bit descriptor
1.1241 + //should twice as long as 16-bit des.
1.1242 + strLen8 = str8.Length();
1.1243 + TEST2(strLen8,len16*2);
1.1244 +
1.1245 + const TUint16* p16a = (TUint16*)str8.Ptr();
1.1246 + const TUint16* p16b = p16.Ptr();
1.1247 + //compares content of descriptors byte by byte
1.1248 + r = Mem::Compare(p16a,strLen8/2,p16b,len16);
1.1249 + TEST2(r,KErrNone);
1.1250 +
1.1251 + //=================read TDes8 using TDes16=====================
1.1252 + r = repository->Get(KString12, str);
1.1253 + TEST2(r, KErrNone);
1.1254 +
1.1255 + //16-bit descriptor holding the same data as 8-bit descriptor
1.1256 + //should be half a length of a 8-bit desc
1.1257 + strLen = str.Length();
1.1258 + TEST2(strLen,len8/2);
1.1259 +
1.1260 + const TUint8* p8a = (TUint8*)str.Ptr();
1.1261 + const TUint8* p8b = p8.Ptr();
1.1262 + //compares content of descriptors byte by byte
1.1263 + r = Mem::Compare(p8a,strLen*2,p8b,len8);
1.1264 + TEST2(r,KErrNone);
1.1265 +
1.1266 + //================writting to TDes16 using TDes8===============
1.1267 + r = repository->Set(KString11,KString12_InitialValue);
1.1268 + TEST2(r, KErrNone);
1.1269 + CleanupStack::PopAndDestroy(repository);
1.1270 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
1.1271 + r = repository->Get(KString11, str8);
1.1272 + strLen8 = str8.Length();
1.1273 + TEST2(strLen8,len8);
1.1274 + TEST(str8==KString12_InitialValue);
1.1275 +
1.1276 + //================writting to TDes8 using TDes16===============
1.1277 + r = repository->Set(KString12,KString11_InitialValue);
1.1278 + TEST2(r, KErrNone);
1.1279 + CleanupStack::PopAndDestroy(repository);
1.1280 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
1.1281 + r = repository->Get(KString12, str);
1.1282 + strLen = str.Length();
1.1283 + TEST2(strLen,len16);
1.1284 + TEST(str==KString11_InitialValue);
1.1285 + CleanupStack::PopAndDestroy(repository);
1.1286 + }
1.1287 +
1.1288 +/**
1.1289 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1433
1.1290 +@SYMTestCaseDesc Central repository panics the client when trying to read 8-bit descriptor with uneven length
1.1291 +@SYMTestPriority High
1.1292 +@SYMTestActions Read 8-bit descriptor with uneven length
1.1293 +@SYMTestExpectedResults The test must not fail or panic .
1.1294 +@SYMDEF INC069013
1.1295 +*/
1.1296 +LOCAL_C void INC069013L()
1.1297 + {
1.1298 + CRepository* repository;
1.1299 + User::LeaveIfNull(repository = CRepository::NewLC(KUidINC069013TestRepository));
1.1300 +
1.1301 + _LIT(KString16, "16BitString");
1.1302 + _LIT8(KString8Odd, "8BitOddString");
1.1303 + _LIT8(KString8Even, "8BitEvenString");
1.1304 +
1.1305 + const TUint32 KString16ID = 1;
1.1306 + const TUint32 KString8OddID = 2;
1.1307 + const TUint32 KString8EvenID = 3;
1.1308 +
1.1309 + TBuf<20> buf;
1.1310 + TInt r = KErrNone;
1.1311 + TInt actualLength = 0;
1.1312 +
1.1313 + //test for string stored as 16 bit
1.1314 + r = repository->Get(KString16ID, buf);
1.1315 + TEST2(r, KErrNone);
1.1316 +
1.1317 + r = repository->Get(KString16ID, buf, actualLength);
1.1318 + TEST2(r, KErrNone);
1.1319 + TEST2(actualLength, KString16().Length());
1.1320 +
1.1321 + //test for string stored as 8 bit with odd length
1.1322 + r = repository->Get(KString8OddID, buf);
1.1323 + TEST2(r, KErrNone);
1.1324 +
1.1325 + r = repository->Get(KString8OddID, buf, actualLength);
1.1326 + TEST2(r, KErrNone);
1.1327 + TEST2(actualLength, (KString8Odd().Length() + 1) / 2);
1.1328 +
1.1329 + //test for string stored as 8 bit with even length
1.1330 + r = repository->Get(KString8EvenID, buf);
1.1331 + TEST2(r, KErrNone);
1.1332 +
1.1333 + r = repository->Get(KString8EvenID, buf, actualLength);
1.1334 + TEST2(r, KErrNone);
1.1335 + TEST2(actualLength, (KString8Even().Length() + 1) / 2);
1.1336 +
1.1337 + CleanupStack::PopAndDestroy(repository);
1.1338 + }
1.1339 +
1.1340 +/**
1.1341 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1434
1.1342 +@SYMTestCaseDesc Central repository doesn't handle corrupt .cre files correctly.
1.1343 +@SYMTestPriority High
1.1344 +@SYMTestActions Open corrupt files from ROM and persists
1.1345 +@SYMTestExpectedResults The test must not fail.
1.1346 +@SYMDEF DEF070731
1.1347 +*/
1.1348 +const TUid KUidCorruptEOF = { 0x00000e0f };
1.1349 +const TUid KUidCorrupt = { 0x00000bad };
1.1350 +
1.1351 +_LIT(KCRep1File, "c:\\private\\10202BE9\\persists\\00000100.cre");
1.1352 +_LIT(KZCorruptEOFFile, "z:\\private\\10202BE9\\00000e0f.cre");
1.1353 +_LIT(KZCorruptFile, "z:\\private\\10202BE9\\00000bad.cre");
1.1354 +
1.1355 +LOCAL_C void DEF070731L()
1.1356 + {
1.1357 + RFs fs;
1.1358 + User::LeaveIfError(fs.Connect());
1.1359 + CleanupClosePushL(fs);
1.1360 +
1.1361 + CFileMan* fm = CFileMan::NewL(fs);
1.1362 + CleanupStack::PushL(fm);
1.1363 +
1.1364 + CRepository* rep;
1.1365 +
1.1366 + // Open ROM cre file with EOF corruption
1.1367 + TheTest.Printf(_L("\nOpen ROM cre file with EOF corruption\n"));
1.1368 + TRAPD(errH, rep=CRepository::NewLC(KUidCorruptEOF));
1.1369 + TEST2(errH, KErrCorrupt);
1.1370 +
1.1371 + // Open corrupt ROM file
1.1372 + TheTest.Printf(_L("\nOpen corrupt ROM file\n"));
1.1373 + TRAPD(errS,rep=CRepository::NewLC(KUidCorrupt));
1.1374 + TEST2(errS, KErrCorrupt);
1.1375 +
1.1376 + // Edit repos with new setting
1.1377 + TheTest.Printf(_L("\nEdit repos with new setting\n"));
1.1378 + User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));
1.1379 + TInt r = rep->Create(KNewInt, KIntValue);
1.1380 + TEST2(r, KErrNone);
1.1381 + CleanupStack::PopAndDestroy(rep);
1.1382 +
1.1383 + // Reopen repos to read from persists file
1.1384 + User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));
1.1385 + TInt newInt;
1.1386 + r=rep->Get(KNewInt, newInt);
1.1387 + TEST2(r, KErrNone);
1.1388 + CleanupStack::PopAndDestroy(rep);
1.1389 +
1.1390 + // Existance of caching functionality invalidates some tests and
1.1391 + // makes them fail, so kill the server to force clearing the cache
1.1392 + r=KillProcess(KCentralRepositoryServerName);
1.1393 + TEST2(r,KErrNone);
1.1394 +
1.1395 + // Copy corrupt EOF file into persists
1.1396 + TheTest.Printf(_L("\nCopy corrupt EOF file into persists dir\n"));
1.1397 + User::LeaveIfError(fm->Copy(KZCorruptEOFFile, KCRep1File));
1.1398 + // Reset read-only bit
1.1399 + User::LeaveIfError(fm->Attribs(KCRep1File,0,KEntryAttReadOnly,TTime(0)));
1.1400 + User::After(KGeneralDelay);
1.1401 + // Open repos, should find corrupt file and use ROM file
1.1402 + User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));
1.1403 + // If we can't find KNewInt, this proves that we are using ROM file
1.1404 + r=rep->Get(KNewInt, newInt);
1.1405 + TEST2(r, KErrNotFound);
1.1406 + // Test that persists file is deleted
1.1407 + TheTest.Printf(_L("\nCheck corrupt EOF file deleted from persists dir\n"));
1.1408 + TEST2 (BaflUtils::FileExists (fs, KCRep1File), EFalse);
1.1409 + // Close repository
1.1410 + CleanupStack::PopAndDestroy(rep);
1.1411 +
1.1412 + // Existance of caching functionality invalidates some tests and
1.1413 + // makes them fail, so kill the server to force clearing the cache
1.1414 + r=KillProcess(KCentralRepositoryServerName);
1.1415 + TEST2(r,KErrNone);
1.1416 +
1.1417 + // Copy corrupt file into persists
1.1418 + TheTest.Printf(_L("\nCopy corrupt file into persists dir\n"));
1.1419 + User::LeaveIfError(fm->Copy(KZCorruptFile, KCRep1File));
1.1420 + // Reset read-only bit
1.1421 + User::LeaveIfError(fm->Attribs(KCRep1File,0,KEntryAttReadOnly,TTime(0)));
1.1422 + User::After(KGeneralDelay);
1.1423 + // Open repos, should find corrupt file and use ROM file
1.1424 + User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));
1.1425 + // Test that file is deleted
1.1426 + TheTest.Printf(_L("\nCheck corrupt file deleted from persists dir\n"));
1.1427 + TEST2 (BaflUtils::FileExists (fs, KCRep1File), EFalse);
1.1428 +
1.1429 + // Close repository
1.1430 + CleanupStack::PopAndDestroy(3);// rep, fs,fm
1.1431 +
1.1432 + }
1.1433 +
1.1434 +// Helper function for DEF084700L
1.1435 +LOCAL_C void ConnectAndCommitSuicideL(void)
1.1436 + {
1.1437 + CRepository* repository;
1.1438 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
1.1439 +
1.1440 + RThread currentThread;
1.1441 + currentThread.Kill(KErrDied);
1.1442 +
1.1443 + // Should never get executed
1.1444 + CleanupStack::PopAndDestroy(repository);
1.1445 + }
1.1446 +
1.1447 +// Helper function for DEF084700L
1.1448 +LOCAL_C TInt SuicidalThread(TAny*)
1.1449 + {
1.1450 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.1451 + if(!cleanup)
1.1452 + return KErrNoMemory;
1.1453 +
1.1454 + TRAP_IGNORE(ConnectAndCommitSuicideL());
1.1455 +
1.1456 + // Should never get executed
1.1457 + delete cleanup;
1.1458 + return KErrNone;
1.1459 + }
1.1460 +
1.1461 +// Helper function for DEF084700L
1.1462 +LOCAL_C void ConnectAndDisconnectL(void)
1.1463 + {
1.1464 + CRepository* repository;
1.1465 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
1.1466 +
1.1467 + CleanupStack::PopAndDestroy(repository);
1.1468 + }
1.1469 +
1.1470 +// Helper function for DEF084700L
1.1471 +LOCAL_C TInt WellBehavedThread(TAny*)
1.1472 + {
1.1473 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.1474 + if(!cleanup)
1.1475 + return KErrNoMemory;
1.1476 +
1.1477 + TRAP_IGNORE(ConnectAndDisconnectL());
1.1478 +
1.1479 + delete cleanup;
1.1480 + return KErrNone;
1.1481 + }
1.1482 +
1.1483 +/**
1.1484 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1683
1.1485 +@SYMTestCaseDesc UIF automated tests crash H4 board
1.1486 +@SYMTestPriority High
1.1487 +@SYMTestActions Open a repository, create a thread, open same repository from that thread, kill the thread
1.1488 + before closing repository, update a setting from main body (trigger notifications). Do the same
1.1489 + thing for a thread which terminates normally for making sure the previous behaviour is maintained
1.1490 +@SYMTestExpectedResults The test must not panic or fail.
1.1491 +@SYMDEF DEF084700
1.1492 +*/
1.1493 +LOCAL_C void DEF084700L()
1.1494 + {
1.1495 + CRepository* repository;
1.1496 + User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1));
1.1497 +
1.1498 + RThread testThread;
1.1499 + _LIT(KThreadName1, "SuicidalTestThread");
1.1500 +
1.1501 + testThread.Create(KThreadName1, SuicidalThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL);
1.1502 +
1.1503 + TRequestStatus requestStatus;
1.1504 + // Request notification when the thread kills itself
1.1505 + testThread.Logon(requestStatus);
1.1506 + // Let the thread execute
1.1507 + testThread.Resume();
1.1508 +
1.1509 + // Wait for suicide
1.1510 + User::WaitForRequest(requestStatus);
1.1511 + // Make sure it's dead
1.1512 + TEST2(requestStatus.Int(), KErrDied);
1.1513 +
1.1514 + const TUint32 KInt1 = 0x1;
1.1515 + TInt i, r = KErrNone;
1.1516 +
1.1517 + r = repository->Get(KInt1, i);
1.1518 + TEST2(r, KErrNone);
1.1519 + r = repository->Set(KInt1, i+1);
1.1520 + // Fails here with KErrServerTerminated before fix because server crashes
1.1521 + TEST2(r, KErrNone);
1.1522 +
1.1523 + // Create another thread which accesses the repository but terminates normally
1.1524 + _LIT(KThreadName2, "WellBehavedTestThread");
1.1525 +
1.1526 + testThread.Create(KThreadName2, WellBehavedThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL);
1.1527 +
1.1528 + // Request notification when the thread terminates normally
1.1529 + testThread.Logon(requestStatus);
1.1530 + // Let the thread execute
1.1531 + testThread.Resume();
1.1532 +
1.1533 + // Wait for old age
1.1534 + User::WaitForRequest(requestStatus);
1.1535 + // Make sure the cause of death is natural
1.1536 + TEST2(requestStatus.Int(), KErrNone);
1.1537 +
1.1538 + r = repository->Get(KInt1, i);
1.1539 + TEST2(r, KErrNone);
1.1540 + r = repository->Set(KInt1, i+1);
1.1541 +
1.1542 + TEST2(r, KErrNone);
1.1543 +
1.1544 + //Reset repository to remove any changes made during this test
1.1545 + r = repository->Reset();
1.1546 + TEST2(r, KErrNone);
1.1547 +
1.1548 + CleanupStack::PopAndDestroy(repository);
1.1549 + }
1.1550 +
1.1551 +/**
1.1552 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1862
1.1553 +@SYMTestCaseDesc [AQP] CommitTransaction returns incorrect error code if Find~L methods run OOM
1.1554 +@SYMTestPriority High
1.1555 +@SYMTestActions Open a repository, start a transaction, then simulate a OOM failure in a TRAPPED
1.1556 + FindL, this will result in client side error and this error should be the returned
1.1557 + error of CommitTransaction.
1.1558 +@SYMTestExpectedResults The test must not panic or fail.
1.1559 +@SYMDEF DEF089945
1.1560 +*/
1.1561 +LOCAL_C void DEF089945L()
1.1562 + {
1.1563 + TInt err=KErrNone;
1.1564 + const TUid testUid={0x10057145};
1.1565 + RArray<TUint32> idArray;
1.1566 +
1.1567 + CRepository* repository;
1.1568 + User::LeaveIfNull(repository = CRepository::NewLC(testUid));
1.1569 +
1.1570 + //-----------SIMULATE CLIENT SIDE TRANSACTION ERROR------------------------------
1.1571 + err=repository->StartTransaction(CRepository::EReadWriteTransaction);
1.1572 + TEST2(err,KErrNone);
1.1573 +
1.1574 + //set the next allocation to fail in the FindL method
1.1575 + __UHEAP_FAILNEXT(1);
1.1576 + TRAP(err,repository->FindL(1,0xFFFFFFFF,idArray));
1.1577 + __UHEAP_TOTAL_RESET;
1.1578 + //uheap failure only happens in debug build
1.1579 +#ifdef _DEBUG
1.1580 + TEST2(err,KErrNoMemory);
1.1581 +#else
1.1582 + TEST2(err,KErrNone);
1.1583 +#endif
1.1584 +
1.1585 + TUint32 errId;
1.1586 + //ensure that the returned code from Commit is same as the last failure error in client
1.1587 + err=repository->CommitTransaction(errId);
1.1588 +#ifdef _DEBUG
1.1589 + TEST2(err,KErrNoMemory);
1.1590 + TEST2(errId,KUnspecifiedKey);
1.1591 +#else
1.1592 + TEST2(err,KErrNone);
1.1593 +#endif
1.1594 + idArray.Reset();
1.1595 +
1.1596 + //----------SIMULATE CLIENT SIDE TRANSACTION ERROR FOLLOWED BY ADDITIONAL OPERATION-----
1.1597 + err=repository->StartTransaction(CRepository::EReadWriteTransaction);
1.1598 + TEST2(err,KErrNone);
1.1599 + //set the next allocation to fail in the FindL method
1.1600 + __UHEAP_FAILNEXT(1);
1.1601 + TRAP(err,repository->FindL(1,0xFFFFFFFF,idArray));
1.1602 + __UHEAP_TOTAL_RESET;
1.1603 +#ifdef _DEBUG
1.1604 + TEST2(err,KErrNoMemory);
1.1605 +#else
1.1606 + TEST2(err,KErrNone);
1.1607 +#endif
1.1608 +
1.1609 + //now try to execute another operation following the failure
1.1610 + TReal realValue;
1.1611 + err=repository->Set(1,realValue);
1.1612 +#ifdef _DEBUG
1.1613 + TEST2(err,KErrAbort);
1.1614 +#else
1.1615 + TEST2(err,KErrArgument);
1.1616 +#endif
1.1617 +
1.1618 + err=repository->CommitTransaction(errId);
1.1619 + //confirms that the error returned is the last failure in client side
1.1620 +#ifdef _DEBUG
1.1621 + TEST2(err,KErrNoMemory);
1.1622 + TEST2(errId,KUnspecifiedKey);
1.1623 +#else
1.1624 + TEST2(err,KErrArgument);
1.1625 +#endif
1.1626 + idArray.Reset();
1.1627 +
1.1628 + //---------SIMULATE SERVER SIDE ERROR FOLLOWED BY CLIENT SIDE ERROR-------------------
1.1629 + err=repository->StartTransaction(CRepository::EReadWriteTransaction);
1.1630 + TEST2(err,KErrNone);
1.1631 +
1.1632 + //server error
1.1633 + err=repository->Set(1,realValue);
1.1634 + TEST2(err,KErrArgument);
1.1635 +
1.1636 + //client error
1.1637 + __UHEAP_FAILNEXT(1);
1.1638 + TInt ret=KErrNone;
1.1639 + TRAP(err,ret=repository->FindL(1,0xFFFFFFFF,idArray));
1.1640 + __UHEAP_TOTAL_RESET;
1.1641 + TEST2(ret,KErrAbort);
1.1642 +
1.1643 + err=repository->CommitTransaction(errId);
1.1644 + //confirms that the error returned is the last failure in server side
1.1645 + TEST2(err,KErrArgument);
1.1646 + TEST2(errId,1);
1.1647 + idArray.Reset();
1.1648 +
1.1649 + //clean up stuff
1.1650 + idArray.Close();
1.1651 + CleanupStack::PopAndDestroy(repository);
1.1652 + }
1.1653 +
1.1654 +/**
1.1655 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3242
1.1656 +@SYMTestCaseDesc Memory card: Backup to memory card causes phone freeze.
1.1657 +@SYMTestPriority High
1.1658 +@SYMTestActions Open a repository with a corrupt ini file and check that
1.1659 + the call to CRepository::NewLC leaves with KErrCorrupt and does not panic.
1.1660 +@SYMTestExpectedResults The call to CRepository::NewLC should return with KErrCorrupt and
1.1661 + the test must not panic or fail.
1.1662 +@SYMDEF PDEF098500
1.1663 +*/
1.1664 +LOCAL_C void PDEF098500()
1.1665 + {
1.1666 + CRepository* repository = NULL;
1.1667 +
1.1668 + TRAPD(err,repository = CRepository::NewLC(KUidPDEF098500LRepository));
1.1669 +
1.1670 + //We expect the above call to leave with KErrCorrupt so repository should be NULL
1.1671 + TEST(repository == NULL);
1.1672 + TEST2(err, KErrCorrupt);
1.1673 +
1.1674 + //No PopAndDestroy required as above call is expected to leave
1.1675 +
1.1676 + }
1.1677 +
1.1678 +/**
1.1679 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1884
1.1680 +@SYMTestCaseDesc DEF093855: CenRep cancels transactions if they exceed 5 seconds...
1.1681 +@SYMTestPriority High
1.1682 +@SYMTestActions Open a repository, start a transaction, then wait more than default cache timeout
1.1683 + to let the normal eviction clean out the cache, call a function to reload the repository,
1.1684 + check that the transaction is still valid, rollback the transaction to check the
1.1685 + repository unload/reload during an open transaction doesn't cause a panic when transaction is rolled back.
1.1686 +@SYMTestExpectedResults The test must not panic or fail.
1.1687 +@SYMDEF DEF093855
1.1688 +*/
1.1689 +LOCAL_C void DEF093855L()
1.1690 + {
1.1691 + TInt err=KErrNone;
1.1692 +
1.1693 + // make sure no items are in the cache
1.1694 + KillProcess(KCentralRepositoryServerName);
1.1695 +
1.1696 + // connect
1.1697 + CRepository* repository;
1.1698 + User::LeaveIfNull(repository = CRepository::NewLC(KUidRep1));
1.1699 +
1.1700 + // Begin concurrent read write transaction
1.1701 + err = repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.1702 + TEST2(err, KErrNone);
1.1703 +
1.1704 + TInt val;
1.1705 + const TInt KIntTestValue = 10;
1.1706 + // get test value, make sure it is KIntTestValue
1.1707 + err = repository->Get(0x02010100,val);
1.1708 + TEST2(err, KErrNone);
1.1709 + TEST2(val, KIntTestValue);
1.1710 +
1.1711 + // change the value in transaction
1.1712 + TInt r = repository->Set(0x02010100, KIntValue);
1.1713 + TEST2(r, KErrNone);
1.1714 +
1.1715 + // wait for the repository to be removed from memory
1.1716 + CleanupRepositoryCache();
1.1717 +
1.1718 + // check that the transaction is not aborted, still in memory and keeps the value set during the transaction
1.1719 + err = repository->Get(0x02010100,val);
1.1720 + TEST2(err, KErrNone);
1.1721 + TEST2(val, KIntValue);
1.1722 +
1.1723 + // rollback to check if RollbackTransaction works, and to reset the value to KIntTestValue
1.1724 + repository->RollbackTransaction();
1.1725 +
1.1726 + // Begin another transaction
1.1727 + err = repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.1728 + TEST2(err, KErrNone);
1.1729 +
1.1730 + // get test value, make sure it is still KIntTestValue (successfully rolled back)
1.1731 + err = repository->Get(0x02010100,val);
1.1732 + TEST2(err, KErrNone);
1.1733 + TEST2(val, KIntTestValue);
1.1734 +
1.1735 + // change the value in transaction
1.1736 + r = repository->Set(0x02010100, KIntValue);
1.1737 + TEST2(r, KErrNone);
1.1738 +
1.1739 + // wait for the repository to be removed from memory
1.1740 + CleanupRepositoryCache();
1.1741 +
1.1742 + // check that the transaction is not aborted, still in memory and keeps the value set during the transaction
1.1743 + err = repository->Get(0x02010100,val);
1.1744 + TEST2(err, KErrNone);
1.1745 + TEST2(val, KIntValue);
1.1746 +
1.1747 + // commit to check if CommitTransaction works
1.1748 + TUint32 keyInfo;
1.1749 + repository->CommitTransaction(keyInfo);
1.1750 + TEST2(err, KErrNone);
1.1751 + TEST2(keyInfo, 1);
1.1752 +
1.1753 + // check that the value is set during the transaction (in shared rep settings)
1.1754 + err = repository->Get(0x02010100,val);
1.1755 + TEST2(err, KErrNone);
1.1756 + TEST2(val, KIntValue);
1.1757 +
1.1758 + // close repository
1.1759 + CleanupStack::PopAndDestroy(repository);
1.1760 +
1.1761 + // make sure the repository is unloaded from cache
1.1762 + KillProcess(KCentralRepositoryServerName);
1.1763 +
1.1764 + // reopen the repository
1.1765 + User::LeaveIfNull(repository = CRepository::NewLC(KUidRep1));
1.1766 +
1.1767 + // get test value, to check if it had been successfully persisted
1.1768 + err = repository->Get(0x02010100,val);
1.1769 + TEST2(err, KErrNone);
1.1770 + TEST2(val, KIntValue);
1.1771 +
1.1772 + // reset the setting back to the original value
1.1773 + r = repository->Set(0x02010100, KIntTestValue);
1.1774 + TEST2(r, KErrNone);
1.1775 +
1.1776 + //Reset repository to remove any changes made during this test
1.1777 + r = repository->Reset();
1.1778 + TEST2(r, KErrNone);
1.1779 +
1.1780 + // close repository
1.1781 + CleanupStack::PopAndDestroy(repository);
1.1782 + }
1.1783 +
1.1784 +/**
1.1785 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3477
1.1786 +@SYMTestCaseDesc PDEF106507: Central repository doesn't handle corruption of the installdir.bin file properly
1.1787 +@SYMTestPriority High
1.1788 +@SYMTestActions Replaces installdir.bin file with a corrupted version, then shuts down the server and restarts it (with CRepository::NewL) This causes the file to be re-read, and as it is corrupt it should get deleted and re-created. The test checks that the server does not panic.
1.1789 +@SYMTestExpectedResults The Server should not panic when trying to read the corrupt file, and should return KErrNone
1.1790 +@SYMDEF PDEF106507
1.1791 +*/
1.1792 +LOCAL_C void PDEF106507L()
1.1793 + {
1.1794 + _LIT(KInstallDirFile, "C:\\private\\10202be9\\persists\\installdir.bin");
1.1795 + _LIT(KInstallDirFileBad1, "Z:\\private\\10202be9\\installdir_corrupt1.bin");
1.1796 + _LIT(KInstallDirFileBad2, "Z:\\private\\10202be9\\installdir_corrupt2.bin");
1.1797 + RFs fs;
1.1798 + User::LeaveIfError(fs.Connect());
1.1799 + CleanupClosePushL(fs);
1.1800 +
1.1801 + CFileMan* fm = CFileMan::NewL(fs);
1.1802 + CleanupStack::PushL(fm);
1.1803 +
1.1804 + // copy first corrupt file into centrep private directory (this file has data area corrupted)
1.1805 + TheTest.Printf(_L("\nCopy first corrupt installdir.bin file into persists dir\n"));
1.1806 + User::LeaveIfError(fm->Copy(KInstallDirFileBad1, KInstallDirFile));
1.1807 + // Reset read-only bit
1.1808 + User::LeaveIfError(fm->Attribs(KInstallDirFile,0,KEntryAttReadOnly,TTime(0)));
1.1809 +
1.1810 + // Kill server so that next test will restart and internalize file
1.1811 + TInt error = KillProcess(KCentralRepositoryServerName);
1.1812 + TEST2(error, KErrNone);
1.1813 +
1.1814 + // Start server and check it does not panic
1.1815 + CRepository* repository = NULL;
1.1816 + TRAP(error, repository = CRepository::NewL(KUidRep1));
1.1817 + TEST2(error, KErrNone);
1.1818 + delete repository;
1.1819 +
1.1820 + // test the second corrupted file (this file has header information corrupted)
1.1821 + TheTest.Printf(_L("\nCopy second corrupt installdir.bin file into persists dir\n"));
1.1822 + User::LeaveIfError(fm->Copy(KInstallDirFileBad2, KInstallDirFile));
1.1823 + // Reset read-only bit
1.1824 + User::LeaveIfError(fm->Attribs(KInstallDirFile,0,KEntryAttReadOnly,TTime(0)));
1.1825 +
1.1826 + // Kill server so that next test will reconnect and recreate resources
1.1827 + error = KillProcess(KCentralRepositoryServerName);
1.1828 + TEST2(error, KErrNone);
1.1829 +
1.1830 + // Start server and check it does not panic
1.1831 + TRAP(error, repository = CRepository::NewL(KUidRep1));
1.1832 + TEST2(error, KErrNone);
1.1833 + delete repository;
1.1834 +
1.1835 + CleanupStack::PopAndDestroy(2); //fs, fm
1.1836 + }
1.1837 +
1.1838 +/**
1.1839 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3517
1.1840 +@SYMTestCaseDesc R3.2 stability problems: CentralRepositorySrv crash
1.1841 +@SYMTestPriority High
1.1842 +@SYMTestActions Attempt to open a .cre file which has a corrupt UID. Ensure that
1.1843 + the error is dealt with properly.
1.1844 +@SYMTestExpectedResults The test must not fail.
1.1845 +@SYMDEF INC108803
1.1846 +*/
1.1847 +
1.1848 +_LIT(KZCorruptFile1, "z:\\private\\10202BE9\\101f8764.cre");
1.1849 +_LIT(KCCorruptFile1, "c:\\private\\10202BE9\\persists\\101f8764.cre");
1.1850 +_LIT(KCCorruptFile2, "c:\\private\\10202BE9\\persists\\101f8765.cre");
1.1851 +
1.1852 +const TUid KUidCorruptUid1 = { 0x101f8764 };
1.1853 +const TUid KUidCorruptUid2 = { 0x101f8765 };
1.1854 +
1.1855 +LOCAL_C void INC108803L()
1.1856 + {
1.1857 +
1.1858 + TInt err = KErrNone;
1.1859 +
1.1860 + RFs fs;
1.1861 + User::LeaveIfError(fs.Connect());
1.1862 + CleanupClosePushL(fs);
1.1863 +
1.1864 + CFileMan* fm = CFileMan::NewL(fs);
1.1865 + CleanupStack::PushL(fm);
1.1866 +
1.1867 + CRepository* rep = NULL;
1.1868 +
1.1869 + // Attempt to open a repository from a .cre file which has a corrupt UID
1.1870 + // The .cre file exists on the Z drive only. This test ensures that
1.1871 + // the corruption of the .cre file is detected and that the correct error
1.1872 + // code, KErrCorrupt, is returned to the client.
1.1873 + // This test will
1.1874 + // 1. Look on c drive, be unable to find the file
1.1875 + // 2. Look in z drive, find the file with the specified UID,
1.1876 + // determine that the file is corrupt and return KErrCorupt.
1.1877 +
1.1878 + TheTest.Printf(_L("\nAttempt to open ROM cre file with UID corruption\n"));
1.1879 + TRAP(err, rep = CRepository::NewLC(KUidCorruptUid1); CleanupStack::Pop(rep););
1.1880 + TEST2(err, KErrCorrupt);
1.1881 +
1.1882 + // Copy the corrupt .cre file into the persists directory for the next test
1.1883 + User::LeaveIfError(fm->Copy(KZCorruptFile1, KCCorruptFile1 ));
1.1884 + // Reset read-only bit
1.1885 + User::LeaveIfError(fm->Attribs(KCCorruptFile1,0,KEntryAttReadOnly,TTime(0)));
1.1886 + User::After(KGeneralDelay);
1.1887 +
1.1888 + // Attempt to open a repository which has a .cre file with a corrupt UID.
1.1889 + // The .cre file exists on the C and Z drives. (This test ensures that the
1.1890 + // corrupt .cre file on the C Drive is deleted).
1.1891 + // This test will
1.1892 + // 1.Look in the C Drive, find the file with the specified UID
1.1893 + // determine that the file is corrupt and delete the file
1.1894 + // 2. Look in the Z Drive, find the file with the specified UID,
1.1895 + // determine that the file is corrupt and return KErrCorupt.
1.1896 +
1.1897 + TheTest.Printf(_L("\nAttempt to open persists cre file with UID corruption\n"));
1.1898 + TRAP (err, rep = CRepository::NewLC(KUidCorruptUid1); CleanupStack::Pop(rep););
1.1899 + TEST2(err, KErrCorrupt);
1.1900 + TheTest.Printf(_L("\nCheck corrupt file deleted from persists dir\n"));
1.1901 + TEST2 (BaflUtils::FileExists (fs, KCCorruptFile1), EFalse);
1.1902 +
1.1903 + // Copy a second corrupt .cre file into the persists directory
1.1904 + // (Note that an associated ini file
1.1905 + // z:\\private\\10202BE9\\101f8765.txt exists and is not corrupt)
1.1906 +
1.1907 + User::LeaveIfError(fm->Copy(KZCorruptFile1, KCCorruptFile2));
1.1908 + TEST2 (BaflUtils::FileExists (fs, KCCorruptFile2), ETrue);
1.1909 + // Reset read-only bit
1.1910 + User::LeaveIfError(fm->Attribs(KCCorruptFile2,0,KEntryAttReadOnly,TTime(0)));
1.1911 + User::After(KGeneralDelay);
1.1912 +
1.1913 + // Attempt to open a corrupt repository. This will fail and the .cre file on the
1.1914 + // C Drive will be deleted. Fall-back to the Z drive occurs. The associated ini file
1.1915 + // is found.
1.1916 + // Attempt to use the resulting repository by using a Reset operation. No panics should
1.1917 + // occur.
1.1918 + TheTest.Printf(_L("\nAttempt to open corrupt persists cre file, re-create from txt file\n"));
1.1919 + TRAP (err, rep = CRepository::NewLC(KUidCorruptUid2); CleanupStack::Pop(rep););
1.1920 + TEST2 (BaflUtils::FileExists (fs, KCCorruptFile2), EFalse);
1.1921 + TEST2(err, KErrNone);
1.1922 + ASSERT(rep != NULL);
1.1923 + rep->Reset();
1.1924 +
1.1925 + // Clean up any files created on the C Drive
1.1926 + CleanupFileFromCDriveL(KUidCorruptUid1);
1.1927 + CleanupFileFromCDriveL(KUidCorruptUid2);
1.1928 +
1.1929 + delete rep;
1.1930 + CleanupStack::PopAndDestroy(2, &fs); // fm, fs
1.1931 + }
1.1932 +
1.1933 +
1.1934 +/**
1.1935 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3545
1.1936 +@SYMTestCaseDesc The corrupted Cache ini file should cause CentralRepositorySrv panic in debug mode
1.1937 + but keep running with the default values in release mode.
1.1938 +@SYMTestPriority High
1.1939 +@SYMTestActions Kill CentralRepositorySrv and restart it with the corrupted Cache ini file.
1.1940 + Ensure that:
1.1941 + . in debug mode, the client will fail to create a CRepository pointer because
1.1942 + the server has panicked.
1.1943 + . in release mode, the client will be able to create a CRepository pointer because
1.1944 + the server keeps running with the default values.
1.1945 +@SYMTestExpectedResults The test must not fail.
1.1946 +@SYMDEF DEF109390
1.1947 +*/
1.1948 +
1.1949 +_LIT(KZCorruptIniFile, "z:\\private\\10202BE9\\cache_corrupt.ini");
1.1950 +_LIT(KCCorruptIniFile, "c:\\private\\10202BE9\\centrep.ini");
1.1951 +_LIT(KZRepFile, "z:\\private\\10202BE9\\00000001.txt");
1.1952 +_LIT(KCRepFile, "c:\\private\\10202BE9\\persists\\00000001.txt");
1.1953 +
1.1954 +const TUid KTestRepUid = { 0x00000001};
1.1955 +
1.1956 +LOCAL_C void DEF109390L()
1.1957 + {
1.1958 + TInt err(KErrNone);
1.1959 +
1.1960 + RFs fs;
1.1961 + User::LeaveIfError(fs.Connect());
1.1962 + CleanupClosePushL(fs);
1.1963 +
1.1964 + CFileMan* fm = CFileMan::NewL(fs);
1.1965 + CleanupStack::PushL(fm);
1.1966 +
1.1967 + // Copy the corrupted Cache ini file to install directory.
1.1968 + TheTest.Printf(_L("\nCopy the corrupted Cache ini file to install directory.\n"));
1.1969 + User::LeaveIfError(fm->Copy(KZCorruptIniFile, KCCorruptIniFile));
1.1970 + // Reset read-only bit
1.1971 + User::LeaveIfError(fm->Attribs(KCCorruptIniFile,0,KEntryAttReadOnly,TTime(0)));
1.1972 +
1.1973 + // Copy a good repository file to persist directory to verify whether the cenrep server is
1.1974 + // able to start up.
1.1975 + TheTest.Printf(_L("\nCopy the repository file to persist directory.\n"));
1.1976 + User::LeaveIfError(fm->Copy(KZRepFile, KCRepFile));
1.1977 + // Reset read-only bit
1.1978 + User::LeaveIfError(fm->Attribs(KCRepFile,0,KEntryAttReadOnly,TTime(0)));
1.1979 +
1.1980 + // Kill server so that next test will restart it.
1.1981 + err=KillProcess(KCentralRepositoryServerName);
1.1982 + TEST2(err,KErrNone);
1.1983 +
1.1984 + User::After(KGeneralDelay);
1.1985 +
1.1986 + CRepository* rep = NULL;
1.1987 + TRAP(err, rep = CRepository::NewLC(KTestRepUid); CleanupStack::PopAndDestroy(rep););
1.1988 +
1.1989 + #ifdef _DEBUG
1.1990 + // in debug mode, CRepository::NewLC should leave with leave code KErrGeneral.
1.1991 + TheTest.Printf(_L("Debug mode err = %d.\n"),err);
1.1992 + TEST2(err, KErrGeneral);
1.1993 + #else
1.1994 + // in release mode, CRepository::NewLC should return a valid CRepository pointer successfully.
1.1995 + TheTest.Printf(_L("Release mode err = %d.\n"),err);
1.1996 + TEST2(err, KErrNone);
1.1997 + #endif
1.1998 +
1.1999 + // Clean up the repository files created on the C Drive
1.2000 + CleanupFileFromCDriveL(KTestRepUid);
1.2001 +
1.2002 + // Clean up the corrupted ini file on the C Drive
1.2003 + User::LeaveIfError(fm->Delete(KCCorruptIniFile));
1.2004 +
1.2005 + // pop the cleanup stack for fm & fs
1.2006 + CleanupStack::PopAndDestroy(2, &fs);
1.2007 +
1.2008 + // Kill the Cenrep server so that it can it can be restarted by the client
1.2009 + // without the corrupted Cache ini file.
1.2010 + err=KillProcess(KCentralRepositoryServerName);
1.2011 + TEST2(err,KErrNone);
1.2012 + }
1.2013 +
1.2014 +/**
1.2015 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4024
1.2016 +@SYMTestCaseDesc
1.2017 +Test that the UID compare function works properly with large UID's. Since
1.2018 +CObservable::CompareTUidValues() is a private function and cannot be accessed
1.2019 +directly, CObservable::AddObserverL()and CObservable::FindConnectedRepository()
1.2020 +are used to infer the correct operation.
1.2021 +@SYMTestPriority High
1.2022 +@SYMTestActions
1.2023 +-Compare a large positive UID and a very negative UID
1.2024 +-Compare a large positive UID and a large positive UID
1.2025 +-Compare a very negative UID and a very negative UID
1.2026 +-Compare two very large but equivalent UID's.
1.2027 +@SYMTestExpectedResults All UID's added to a sorted list can be found later, regardless of size and sign.
1.2028 +@SYMDEF DEF116043
1.2029 +@SYMUnit CObservable::CompareTUidValues()
1.2030 +*/
1.2031 +LOCAL_C void DEF116043L()
1.2032 + {
1.2033 + const TUid KLargePositive1 = {0x7FFFFFFF};
1.2034 + const TUid KLargePositive2 = {0x7FFFFFFE};
1.2035 + const TUid KLargeNegative = {0x8FFFFFFF};
1.2036 +
1.2037 + CObservable* ob = CObservable::NewLC();
1.2038 +
1.2039 + // Add a variety of UID's to work with, including large positives, a very negative,
1.2040 + // and duplicates
1.2041 + ob->AddObserverL(KLargePositive1, NULL);
1.2042 + ob->AddObserverL(KLargeNegative, NULL);
1.2043 + ob->AddObserverL(KLargePositive2, NULL);
1.2044 + ob->AddObserverL(KLargePositive1, NULL);
1.2045 +
1.2046 + // Look for a large positive and expect a non-negative index
1.2047 + TEST(ob->FindConnectedRepository(KLargePositive1) >= 0);
1.2048 +
1.2049 + // Look for another large positive and expect a non-negative index
1.2050 + TEST(ob->FindConnectedRepository(KLargePositive2) >= 0);
1.2051 +
1.2052 + // Look for a very negative and expect a non-negative index.
1.2053 + // This will fail under 'UID1 - UID2' implementations.
1.2054 + TEST(ob->FindConnectedRepository(KLargeNegative) >= 0);
1.2055 +
1.2056 + CleanupStack::PopAndDestroy(ob);
1.2057 + }
1.2058 +
1.2059 +/**
1.2060 +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4081
1.2061 +@SYMTestCaseDesc
1.2062 +Test that the Observer compare function works properly with large UID's
1.2063 +@SYMTestPriority High
1.2064 +@SYMTestActions The test will insert a set of pointers with very big and small unsigned address
1.2065 +and ensure that the correct order is inserted in the list
1.2066 +@SYMTestExpectedResults the pointer is inserted in the correct order
1.2067 +@SYMDEF DEF132807
1.2068 +*/
1.2069 +LOCAL_C void DEF132807L()
1.2070 + {
1.2071 + CObservable* ob = CObservable::NewLC();
1.2072 +
1.2073 + const TUid KReposUid={0x87654321};
1.2074 +
1.2075 + ob->AddObserverL(KReposUid,(CServerRepository*)0x7FFFFFFF);
1.2076 + ob->AddObserverL(KReposUid,(CServerRepository*)0x7FFFFFFE);
1.2077 + ob->AddObserverL(KReposUid,(CServerRepository*)0x8FFFFFFF);
1.2078 + ob->AddObserverL(KReposUid,(CServerRepository*)0x00000001);
1.2079 +
1.2080 + TEST(ob->iObservers.Count()==4);
1.2081 + CObservable::TRepositoryObserverInfo pos1=ob->iObservers[0];
1.2082 + TEST(pos1.iRepositoryPointer==(CServerRepository*)0x00000001);
1.2083 + CObservable::TRepositoryObserverInfo pos2=ob->iObservers[1];
1.2084 + TEST(pos2.iRepositoryPointer==(CServerRepository*)0x7FFFFFFE);
1.2085 + CObservable::TRepositoryObserverInfo pos3=ob->iObservers[2];
1.2086 + TEST(pos3.iRepositoryPointer==(CServerRepository*)0x7FFFFFFF);
1.2087 + CObservable::TRepositoryObserverInfo pos4=ob->iObservers[3];
1.2088 + TEST(pos4.iRepositoryPointer==(CServerRepository*)0x8FFFFFFF);
1.2089 + CleanupStack::PopAndDestroy(ob);
1.2090 + }
1.2091 +
1.2092 +//a test class notify handler
1.2093 +//the notify handler will check the value for different test case
1.2094 +static TInt currentTestCaseID=0;
1.2095 +
1.2096 +class CTestNotifyHandler : public CBase, public MCenRepNotifyHandlerCallback
1.2097 + {
1.2098 +public:
1.2099 + static CTestNotifyHandler* NewL()
1.2100 + {
1.2101 + return new (ELeave)CTestNotifyHandler;
1.2102 + }
1.2103 + ~CTestNotifyHandler(){}
1.2104 + // Notification handlers
1.2105 + void HandleNotifyInt(TUint32 aId, TInt aNewValue)
1.2106 + {
1.2107 + if (currentTestCaseID==0)
1.2108 + return;
1.2109 + else if(currentTestCaseID==1)
1.2110 + TEST(aId==1 && aNewValue==208);
1.2111 + }
1.2112 + void HandleNotifyReal(TUint32 aId, TReal /*aNewValue*/)
1.2113 + {
1.2114 + if (currentTestCaseID==2)
1.2115 + {
1.2116 + TEST(aId==1);
1.2117 + CActiveScheduler::Stop();
1.2118 + }
1.2119 + }
1.2120 + void HandleNotifyString(TUint32 /*aId*/, const TDesC16& /*aNewValue*/)
1.2121 + {
1.2122 + }
1.2123 + void HandleNotifyBinary(TUint32 /*aId*/, const TDesC8& /*aNewValue*/)
1.2124 + {
1.2125 + }
1.2126 + void HandleNotifyGeneric(TUint32 /*aId*/)
1.2127 + {
1.2128 + }
1.2129 + void HandleNotifyError(TUint32 aId, TInt error, CCenRepNotifyHandler* /*aHandler*/)
1.2130 + {
1.2131 + if (currentTestCaseID==0)
1.2132 + return;
1.2133 + else if (currentTestCaseID==1)
1.2134 + TEST((TInt)aId==-11 && error==KErrArgument);
1.2135 + else if (currentTestCaseID==2)
1.2136 + TEST(aId==1 && error==KErrArgument);
1.2137 + else if (currentTestCaseID==3)
1.2138 + TEST(aId== 10000 && error==KErrPermissionDenied);
1.2139 +
1.2140 + CActiveScheduler::Stop();
1.2141 + }
1.2142 +private:
1.2143 + CTestNotifyHandler(){}
1.2144 + };
1.2145 +
1.2146 +/**
1.2147 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4035
1.2148 +@SYMTestCaseDesc Notify Handling in centralrepository under different error conditions
1.2149 +@SYMTestPriority High
1.2150 +@SYMTestActions Testing the CRepository::NotifyRequest under different error condition
1.2151 + Testing the CCenrepNotifierHandler under different error condition
1.2152 +@SYMTestExpectedResults Test should pass and exhibit the expected behaviour
1.2153 +@SYMDEF DEF117987
1.2154 +*/
1.2155 +LOCAL_C void DEF117987L()
1.2156 + {
1.2157 + __UHEAP_MARK;
1.2158 +
1.2159 + CActiveScheduler* s=new(ELeave) CActiveScheduler;
1.2160 + CleanupStack::PushL(s);
1.2161 + CActiveScheduler::Install(s);
1.2162 +
1.2163 + const TUid KCDUid = {0xF0000001};
1.2164 + CRepository* rep=CRepository::NewL(KCDUid);
1.2165 +
1.2166 + TRequestStatus ts,ts1;
1.2167 +
1.2168 + //-----------------single notification test-----------------------
1.2169 + //Negative testing for Double notification on same setting
1.2170 + TInt ret=rep->NotifyRequest(1,ts);
1.2171 + TEST(ret==KErrNone);
1.2172 + ret=rep->NotifyRequest(1,ts1);
1.2173 + TEST(ret==KErrNone);
1.2174 + ret=rep->Set(1,123);
1.2175 + User::WaitForRequest(ts);
1.2176 + User::WaitForRequest(ts1);
1.2177 + TEST(ts==1);
1.2178 + TEST(ts1==KErrAlreadyExists);
1.2179 +
1.2180 + //Negative testing for non-existent key---------------------------
1.2181 + ts=KRequestPending;
1.2182 + ret=rep->NotifyRequest(10303,ts);
1.2183 + TEST(ret==KErrNotFound);
1.2184 + TEST(ts==KRequestPending);
1.2185 +
1.2186 + //Negative testing for key we dont have permission----------------
1.2187 + ret=rep->NotifyRequest(10000,ts);
1.2188 + TEST(ret==KErrPermissionDenied);
1.2189 + TEST(ts==KRequestPending);
1.2190 +
1.2191 + //---------------------group notification test--------------------------
1.2192 + ts=KRequestPending;
1.2193 + ts1=KRequestPending;
1.2194 +
1.2195 + //Negative testing for double notification on the same setting range
1.2196 + //set partial key 0 and mask 0xFFFFFF00 to filter only 0-255
1.2197 + ret=rep->NotifyRequest(0,0xFFFFFF00,ts);
1.2198 + TEST(ret==KErrNone);
1.2199 + //second notification request on the same partial key and mask should not fail
1.2200 + ret=rep->NotifyRequest(0,0xFFFFFF00,ts1);
1.2201 + TEST(ret==KErrNone);
1.2202 + ret=rep->Set(1,246);
1.2203 + User::WaitForRequest(ts);
1.2204 + User::WaitForRequest(ts1);
1.2205 + TEST(ts==1);
1.2206 + TEST(ts1==1);
1.2207 +
1.2208 + //Negative testing for unknown range------------------------------
1.2209 + //this will not return error code for range notification as it is intended for
1.2210 + //to cover keys created later in the future.
1.2211 + ts=KRequestPending;
1.2212 + ret=rep->NotifyRequest(100000,0xFFFFFFFF,ts);
1.2213 + TEST(ret==KErrNone);
1.2214 + ret=rep->NotifyCancel(100000,0xFFFFFFFF);
1.2215 + User::WaitForAnyRequest();
1.2216 + TEST(ret==KErrNone);
1.2217 + TEST(ts==KUnspecifiedKey);
1.2218 +
1.2219 + //Negative testing for key we dont have permission------------------------------
1.2220 + ts=KRequestPending;
1.2221 + ret=rep->NotifyRequest(10000,0xFFFFFFFF,ts);
1.2222 + TEST(ret==KErrNone);
1.2223 + User::WaitForRequest(ts);
1.2224 + TEST(ts==KErrPermissionDenied);
1.2225 +
1.2226 + delete rep;
1.2227 +
1.2228 + //----------------single notification using cenrepnotifhandler-----------
1.2229 + currentTestCaseID=1;
1.2230 + rep=CRepository::NewL(KCDUid);
1.2231 + //create the handler callback
1.2232 + CTestNotifyHandler* callback=CTestNotifyHandler::NewL();
1.2233 +
1.2234 + //now setup the handler
1.2235 + CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EIntKey,1);
1.2236 + CCenRepNotifyHandler* handler2=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EIntKey,1);
1.2237 +
1.2238 + handler->StartListeningL();
1.2239 + handler2->StartListeningL();
1.2240 +
1.2241 + ret=rep->Set(1,208);
1.2242 + TEST(ret==KErrNone);
1.2243 +
1.2244 + CActiveScheduler::Start();
1.2245 +
1.2246 + User::After(1000000);
1.2247 + CleanupStack::PopAndDestroy(2);
1.2248 +
1.2249 + delete callback;
1.2250 + delete rep;
1.2251 +
1.2252 + CleanupStack::PopAndDestroy();
1.2253 +
1.2254 + __UHEAP_MARKEND;
1.2255 + }
1.2256 +
1.2257 +/**
1.2258 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4034
1.2259 +@SYMTestCaseDesc Centrep notifier handler does not check return codes
1.2260 +@SYMTestPriority High
1.2261 +@SYMTestActions Test that error code encountered during handling of notification
1.2262 + results in the HandleNotifyError being invoked
1.2263 +@SYMTestExpectedResults Test should pass and exhibit the expected behaviour
1.2264 +@SYMDEF DEF117848
1.2265 +*/
1.2266 +LOCAL_C void DEF117848L()
1.2267 + {
1.2268 + __UHEAP_MARK;
1.2269 +
1.2270 + CActiveScheduler* s=new(ELeave) CActiveScheduler;
1.2271 + CleanupStack::PushL(s);
1.2272 + CActiveScheduler::Install(s);
1.2273 +
1.2274 + const TUid KCDUid = {0xF0000001};
1.2275 +
1.2276 + //create the handler callback
1.2277 + CTestNotifyHandler* callback=CTestNotifyHandler::NewL();
1.2278 +
1.2279 + //----------------notify handle error test case------------------------------
1.2280 + currentTestCaseID=2;
1.2281 + CRepository* rep=CRepository::NewL(KCDUid);
1.2282 +
1.2283 + //purposely set the notify handler for a key but specifying the wrong type
1.2284 + //this will only be detected during the notification
1.2285 + CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::ERealKey,1);
1.2286 + handler->StartListeningL();
1.2287 + TInt ret=rep->Set(1,199);
1.2288 + TEST(ret==KErrNone);
1.2289 +
1.2290 + CActiveScheduler::Start();
1.2291 + //handlenotify error will be called and validate the error code and then stop the scheduler
1.2292 + handler->StopListening();
1.2293 +
1.2294 + CleanupStack::PopAndDestroy();
1.2295 +
1.2296 + //test for other type of settings
1.2297 + handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EStringKey,1);
1.2298 + handler->StartListeningL();
1.2299 + ret=rep->Set(1,209);
1.2300 + TEST(ret==KErrNone);
1.2301 + CActiveScheduler::Start();
1.2302 + handler->StopListening();
1.2303 + CleanupStack::PopAndDestroy();
1.2304 +
1.2305 + //test for other type of settings
1.2306 + handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EBinaryKey,1);
1.2307 + handler->StartListeningL();
1.2308 + ret=rep->Set(1,309);
1.2309 + TEST(ret==KErrNone);
1.2310 +
1.2311 + CActiveScheduler::Start();
1.2312 + handler->StopListening();
1.2313 + CleanupStack::PopAndDestroy();
1.2314 +
1.2315 + delete callback;
1.2316 + delete rep;
1.2317 +
1.2318 + CleanupStack::PopAndDestroy();
1.2319 +
1.2320 + __UHEAP_MARKEND;
1.2321 + }
1.2322 +
1.2323 +/**
1.2324 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4036
1.2325 +@SYMTestCaseDesc Central Repository Notification Handler flooded with notifications
1.2326 +@SYMTestPriority High
1.2327 +@SYMTestActions Testing the CCenrepNotifierHandler when the client does not have
1.2328 + enough permission when setting up the whole repository notifier.
1.2329 +@SYMTestExpectedResults Test should pass and exhibit the expected behaviour
1.2330 +@SYMDEF DEF118107
1.2331 +*/
1.2332 +LOCAL_C void DEF118107L()
1.2333 + {
1.2334 + __UHEAP_MARK;
1.2335 +
1.2336 + currentTestCaseID = 3;
1.2337 + CActiveScheduler* s=new(ELeave) CActiveScheduler;
1.2338 + CleanupStack::PushL(s);
1.2339 + CActiveScheduler::Install(s);
1.2340 +
1.2341 + const TUid KCDUid = {0xF0000001};
1.2342 + CRepository* rep=CRepository::NewL(KCDUid);
1.2343 +
1.2344 + //create the handler callback
1.2345 + CTestNotifyHandler* callback=CTestNotifyHandler::NewL();
1.2346 +
1.2347 + //create a handler to listen to the whole repository
1.2348 + CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(*callback,*rep);
1.2349 +
1.2350 + //Start listening as a fail should occur as one of repository entries does not
1.2351 + //have the correct capabilities
1.2352 + handler->StartListeningL();
1.2353 +
1.2354 + //This causes the handlenotifyerror to be called which checks that
1.2355 + //KErrPermissionDenied has occured and stops the scheduler.
1.2356 + CActiveScheduler::Start();
1.2357 + handler->StopListening();
1.2358 +
1.2359 + //Cleanup
1.2360 + CleanupStack::PopAndDestroy();
1.2361 +
1.2362 + delete callback;
1.2363 + delete rep;
1.2364 +
1.2365 + CleanupStack::PopAndDestroy();
1.2366 +
1.2367 + __UHEAP_MARKEND;
1.2368 + }
1.2369 +
1.2370 +
1.2371 +// This function creates TServerSetting objects with the data in the ServerSettingStruct array and then
1.2372 +// appends them to the specified RSettingsArray object.
1.2373 +LOCAL_C void SetupSettingsArrayL(RSettingsArray& aSettingsArray,const ServerSettingStruct aSettingStructArr[], TInt aSettingStructArrSize)
1.2374 + {
1.2375 + for(TInt i = 0; i < aSettingStructArrSize; i++)
1.2376 + {
1.2377 + TServerSetting newSetting(aSettingStructArr[i].key);
1.2378 + TInt error;
1.2379 + newSetting.SetIntValue(aSettingStructArr[i].value);
1.2380 + newSetting.SetType(aSettingStructArr[i].meta);
1.2381 + newSetting.SetMeta(aSettingStructArr[i].meta);
1.2382 +
1.2383 + error = aSettingsArray.OrderedInsert(newSetting);
1.2384 +
1.2385 + if(KErrNone != error)
1.2386 + {
1.2387 + newSetting.Reset(); // for safety in case of newSetting is not TInt type.
1.2388 + User::Leave(error);
1.2389 + }
1.2390 + }
1.2391 + }
1.2392 +
1.2393 +// This function compares 2 RSettingsArray arrays. Panics if they are not identical
1.2394 +LOCAL_C void CompareSettingsArrays(const RSettingsArray& aArr1, const RSettingsArray& aArr2)
1.2395 + {
1.2396 + TEST2(aArr1.Count(), aArr2.Count());
1.2397 + for(TInt i = 0; i < aArr2.Count(); i++)
1.2398 + {
1.2399 + if(aArr1[i].IsDeleted())
1.2400 + {
1.2401 + TEST(aArr2[i].IsDeleted());
1.2402 + }
1.2403 + else
1.2404 + {
1.2405 + TEST(aArr1[i] == aArr2[i]);
1.2406 + }
1.2407 + }
1.2408 + }
1.2409 +
1.2410 +// This function compares 2 RArray<TUint32> arrays. Panics if they are not identical
1.2411 +LOCAL_C void CompareUint32Arrays(const RArray<TUint32>& aArr1, const RArray<TUint32>& aArr2)
1.2412 + {
1.2413 + TEST2(aArr1.Count(), aArr2.Count());
1.2414 + for(TInt i = 0; i < aArr2.Count(); i++)
1.2415 + {
1.2416 + TEST(aArr1[i] == aArr2[i]);
1.2417 + }
1.2418 + }
1.2419 +
1.2420 +// This function calls MergerArray() with the pre-set parameters for each merge type and compares the results to
1.2421 +// the reference arrays.
1.2422 +// Also used as the OOM test if aOOMMode is ETrue.
1.2423 +LOCAL_C void MergerArrayTestL(const RSettingsArray aPersistRef[], const RSettingsArray aChangeRef[], const RArray<TUint32> aDeletedRef[], TBool aOOMMode)
1.2424 +
1.2425 + {
1.2426 + // Data used to construct the persistence array for all merge types
1.2427 + static const ServerSettingStruct settingStructPersist[] = {{1,0,1}, {3,KMetaBackup,3}, {5,0,5}, {7,0,7}, {9,KMetaDefaultValue,9}, {11,0,11}, {13,KMetaDefaultValue,13}};
1.2428 +
1.2429 + // Data used to construct the changes array for merge type: ETransactionMerge. Some are marked as deleted.
1.2430 + static const ServerSettingStruct settingStructChangeTrans[] = {{1,TServerSetting::EDeleted,1}, {2,TServerSetting::EDeleted,2}, \
1.2431 + {3,TServerSetting::EDeleted,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}};
1.2432 +
1.2433 + // Data used to construct the changes array for all other merge types than ETransactionMerge. No deleted items.
1.2434 + static const ServerSettingStruct settingStructChange[] = {{1,0,1}, {2,0,2}, {3,0,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}};
1.2435 +
1.2436 + for(TInt i = 0; i < sizeof(KMergerTypes) / sizeof(TMergeType); i++)
1.2437 + {
1.2438 + RSettingsArray persist;
1.2439 + RSettingsArray change;
1.2440 + RArray<TUint32> deleted;
1.2441 + TInt error = KErrNone ;
1.2442 + TInt count = 0;
1.2443 +
1.2444 + do
1.2445 + {
1.2446 + __UHEAP_MARK;
1.2447 +
1.2448 + // Sets up arrays passed into MergeArray()
1.2449 + SetupSettingsArrayL(persist,settingStructPersist, sizeof(settingStructPersist)/sizeof(ServerSettingStruct));
1.2450 + if( ETransactionMerge == KMergerTypes[i] )
1.2451 + {
1.2452 + SetupSettingsArrayL(change,settingStructChangeTrans, sizeof(settingStructChangeTrans)/sizeof(ServerSettingStruct));
1.2453 + }
1.2454 + else
1.2455 + {
1.2456 + SetupSettingsArrayL(change,settingStructChange, sizeof(settingStructChange)/sizeof(ServerSettingStruct));
1.2457 + }
1.2458 +
1.2459 + deleted.InsertInUnsignedKeyOrderL(4);
1.2460 +
1.2461 + if(aOOMMode)
1.2462 + {
1.2463 + __UHEAP_SETFAIL(RHeap::EFailNext, ++count);
1.2464 + }
1.2465 +
1.2466 + error = persist.MergeArray(change, deleted, KMergerTypes[i]);
1.2467 +
1.2468 + if (aOOMMode)
1.2469 + {
1.2470 + TEST(KErrNone == error || KErrNoMemory == error);
1.2471 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.2472 + }
1.2473 + else
1.2474 + {
1.2475 + TEST(KErrNone == error);
1.2476 + // Verifies affected arrays.
1.2477 + CompareSettingsArrays(persist, aPersistRef[i]);
1.2478 + CompareSettingsArrays(change, aChangeRef[i]);
1.2479 + CompareUint32Arrays(deleted, aDeletedRef[i]);
1.2480 + }
1.2481 +
1.2482 + // Resets the arrays.
1.2483 + persist.Reset();
1.2484 + change.Reset();
1.2485 + deleted.Reset();
1.2486 +
1.2487 + __UHEAP_MARKEND;
1.2488 + } while(KErrNoMemory == error);
1.2489 + if (aOOMMode)
1.2490 + {
1.2491 + TheTest.Printf(_L("- MergeArray for type %d succeeded at heap failure rate of %i\n"), KMergerTypes[i], count);
1.2492 + }
1.2493 + }
1.2494 + }
1.2495 +
1.2496 +/**
1.2497 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4037
1.2498 +@SYMTestCaseDesc This test case verifies the re-factored CentralRepository internal merge function (MergeArray).
1.2499 +@SYMTestPriority High
1.2500 +@SYMTestActions For each merger type, calls MergeArray() with the pre-defined arrays: this, aChanges, aDeleted,
1.2501 + which would be changed by the function. Verifies these 3 arrays with the reference arrays as well as
1.2502 + the return code after MergeArray() returns.
1.2503 + This case also carries out the OOM test for function MergeArray().
1.2504 +@SYMTestExpectedResults MergeArray() should return no error and these 3 arrays should be identical with the reference
1.2505 + arrays. In OOM mode, only KErrNoMemory or KErrNone should be returned.
1.2506 +@SYMDEF DEF116629
1.2507 +*/
1.2508 +LOCAL_C void DEF116629L()
1.2509 + {
1.2510 +
1.2511 + // Data used to construct the reference arrays of each merge type:
1.2512 + // ETransactionMerge
1.2513 + const ServerSettingStruct settingStructPersistAfterTrans[] = {{4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}, {11,0,11}, {13,0,13}};
1.2514 + const ServerSettingStruct settingStructChangeAfterTrans[] = {{1,TServerSetting::EDeleted,1},
1.2515 + {3,TServerSetting::EDeleted,3}, {4,0,4}, {6,0,6}, {7,0,8}, {9,0,10}};
1.2516 +
1.2517 + // ERestoreMerge
1.2518 + const ServerSettingStruct settingStructPersistAfterRest[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}, {11,0,11}, {13,0,13}};
1.2519 + const ServerSettingStruct settingStructChangeAfterRest[] = {{2,0,2}, {4,0,4}, {6,0,6}, {7,0,8}, {9,0,10}};
1.2520 +
1.2521 + // ESWIUpgradeMerge
1.2522 + const ServerSettingStruct settingStructPersistAfterSWIUp[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,7}, {9,0,10}, {11,0,11}, {13,0,13}};
1.2523 + const ServerSettingStruct settingStructChangeAfterSWIUp[] = {{2,0,2}, {4,0,4}, {6,0,6}, {9,0,10}};
1.2524 +
1.2525 + // ESWIDowngradeMerge
1.2526 + const ServerSettingStruct settingStructPersistAfterSWIDown[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,7}, {9,0,10}, {11,0,11}};
1.2527 + const ServerSettingStruct settingStructChangeAfterSWIDown[] = {{2,0,2}, {4,0,4}, {6,0,6}, {9,0,10}, {13,0,0}};
1.2528 +
1.2529 + // ERomFlash
1.2530 + const ServerSettingStruct settingStructPersistAfterRomFlash[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,7}, {9,0,10}, {11,0,11}};
1.2531 + const ServerSettingStruct settingStructChangeAfterRomFlash[] = {{1,0,1}, {2,0,2}, {3,0,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}};
1.2532 +
1.2533 + // Reference arrays
1.2534 + RSettingsArray persistAfter[5];
1.2535 + RSettingsArray changeAfter[5];
1.2536 + RArray<TUint32> deletedAfter[5];
1.2537 +
1.2538 + // Sets up the reference arrays for each merge type:
1.2539 + // ETransactionMerge
1.2540 + SetupSettingsArrayL(persistAfter[0],settingStructPersistAfterTrans, sizeof(settingStructPersistAfterTrans)/sizeof(ServerSettingStruct));
1.2541 + SetupSettingsArrayL(changeAfter[0],settingStructChangeAfterTrans, sizeof(settingStructChangeAfterTrans)/sizeof(ServerSettingStruct));
1.2542 + deletedAfter[0].InsertInUnsignedKeyOrderL(3);
1.2543 +
1.2544 + // ERestoreMerge
1.2545 + SetupSettingsArrayL(persistAfter[1],settingStructPersistAfterRest, sizeof(settingStructPersistAfterRest)/sizeof(ServerSettingStruct));
1.2546 + SetupSettingsArrayL(changeAfter[1],settingStructChangeAfterRest, sizeof(settingStructChangeAfterRest)/sizeof(ServerSettingStruct));
1.2547 + //deletedAfter[1] should be empty because Restore Merge should not delete any setting.
1.2548 +
1.2549 + // ESWIUpgradeMerge
1.2550 + SetupSettingsArrayL(persistAfter[2],settingStructPersistAfterSWIUp, sizeof(settingStructPersistAfterSWIUp)/sizeof(ServerSettingStruct));
1.2551 + SetupSettingsArrayL(changeAfter[2],settingStructChangeAfterSWIUp, sizeof(settingStructChangeAfterSWIUp)/sizeof(ServerSettingStruct));
1.2552 + //deletedAfter[2] should be empty because SWIUpgrade Merge should not delete any setting.
1.2553 +
1.2554 + // ESWIDowngradeMerge
1.2555 + SetupSettingsArrayL(persistAfter[3],settingStructPersistAfterSWIDown, sizeof(settingStructPersistAfterSWIDown)/sizeof(ServerSettingStruct));
1.2556 + SetupSettingsArrayL(changeAfter[3],settingStructChangeAfterSWIDown, sizeof(settingStructChangeAfterSWIDown)/sizeof(ServerSettingStruct));
1.2557 + //deletedAfter[3] should be empty because settings deleted by SWIDowngrade Merge are recorded in aChanges.
1.2558 +
1.2559 + // ERomFlash
1.2560 + SetupSettingsArrayL(persistAfter[4],settingStructPersistAfterRomFlash, sizeof(settingStructPersistAfterRomFlash)/sizeof(ServerSettingStruct));
1.2561 + SetupSettingsArrayL(changeAfter[4],settingStructChangeAfterRomFlash, sizeof(settingStructChangeAfterRomFlash)/sizeof(ServerSettingStruct));
1.2562 + //deletedAfter[4] should be empty because settings deleted by RomFlash Merge are recorded in aChanges.
1.2563 +
1.2564 + TheTest.Printf(_L("- Verification test for MergeArray.\n"));
1.2565 + MergerArrayTestL(persistAfter, changeAfter, deletedAfter, EFalse);
1.2566 +
1.2567 + TheTest.Printf(_L("- OOM test for MergeArray.\n"));
1.2568 + MergerArrayTestL(persistAfter, changeAfter, deletedAfter, ETrue);
1.2569 +
1.2570 + // Resets the reference arrays.
1.2571 + for(TInt i = 0; i < sizeof(KMergerTypes) / sizeof(TMergeType); i++)
1.2572 + {
1.2573 + persistAfter[i].Reset();
1.2574 + changeAfter[i].Reset();
1.2575 + deletedAfter[i].Reset();
1.2576 + }
1.2577 + }
1.2578 +/**
1.2579 +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4046
1.2580 +@SYMTestCaseDesc The centrep server panics when it reads a repository text file where
1.2581 + the value of a binary settings is missing.
1.2582 +@SYMTestPriority Medium
1.2583 +@SYMTestActions - Provide a repository text file for this test which have a binary
1.2584 + setting which value is missing.
1.2585 + - Open the repository text file,
1.2586 + this should return KErrCorrupt when parsing the repository text file.
1.2587 +@SYMTestExpectedResults The test must not fail.
1.2588 +@SYMDEF PDEF126904
1.2589 +*/
1.2590 +LOCAL_C void PDEF126904L()
1.2591 + {
1.2592 + const TUid KUidBinaryValueRepositoryFile ={0x1020506B};
1.2593 + const TInt KBinaryValueRepKey = 0xA;
1.2594 + TInt binaryValue = 0;
1.2595 + CRepository* repository = NULL;
1.2596 +
1.2597 + TRAPD(res, repository = CRepository::NewL(KUidBinaryValueRepositoryFile));
1.2598 + if (res == KErrNone)
1.2599 + {
1.2600 + TInt err = KErrNone;
1.2601 + CleanupStack::PushL(repository);
1.2602 + err = repository->Get(KBinaryValueRepKey, binaryValue);
1.2603 + User::LeaveIfError(err);
1.2604 + CleanupStack::PopAndDestroy(repository);
1.2605 + }
1.2606 + else if (res == KErrCorrupt)
1.2607 + {
1.2608 + //This is just to confirm that the err should be KErrCorrupt.
1.2609 + TheTest.Printf(_L("The error is KErrCorrupt as expected.\n"));
1.2610 + }
1.2611 + else
1.2612 + {
1.2613 + User::Leave(res);
1.2614 + }
1.2615 +}
1.2616 +
1.2617 +/**
1.2618 +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4084
1.2619 +@SYMTestCaseDesc Ensure that the timestamp in a TXT file is always zero when not specified
1.2620 + instead of arbitrary value
1.2621 +@SYMTestPriority Medium
1.2622 +@SYMTestActions Create the CHeapRepository object from a TXT keyspace file where no timestamp(legacy)
1.2623 + section is specified. The timestamp should be set to zero
1.2624 +@SYMTestExpectedResults The test must not fail.
1.2625 +@SYMDEF DEF136161
1.2626 +*/
1.2627 +LOCAL_C void DEF136161L()
1.2628 + {
1.2629 + RFs fs;
1.2630 + User::LeaveIfError(fs.Connect());
1.2631 +
1.2632 + //this is a TXT based ROM keyspace
1.2633 + const TUid KTestUid={0x00000001};
1.2634 +
1.2635 + CHeapRepository* repos=CHeapRepository::NewL(KTestUid);
1.2636 + CIniFileIn* iniFile;
1.2637 + TInt ret=CIniFileIn::NewLC(fs,iniFile,_L("z:\\private\\10202be9\\00000001.txt"));
1.2638 + User::LeaveIfError(ret);
1.2639 + repos->ReloadContentL(*iniFile);
1.2640 +
1.2641 + //check the timestamp is always set to zero
1.2642 + TEST(repos->TimeStamp()==TTime(0));
1.2643 +
1.2644 + CleanupStack::PopAndDestroy(iniFile);
1.2645 + delete repos;
1.2646 +
1.2647 + fs.Close();
1.2648 + }
1.2649 +
1.2650 +/**
1.2651 +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4085
1.2652 +@SYMTestCaseDesc Central Repository: Trying to configure Central Repository cache with centrep.in
1.2653 +@SYMTestPriority High
1.2654 +@SYMTestActions Testing that the SWIWatcher does nto leave when the cache configuration exists within
1.2655 +the private data cate
1.2656 +@SYMTestExpectedResults Test should pass and exhibit the expected behaviour
1.2657 +@SYMDEF PDEF139979
1.2658 +*/
1.2659 +LOCAL_C void PDEF139979L()
1.2660 + {
1.2661 + __UHEAP_MARK;
1.2662 + CActiveScheduler* s=new(ELeave) CActiveScheduler;
1.2663 + CleanupStack::PushL(s);
1.2664 + CActiveScheduler::Install(s);
1.2665 +
1.2666 + RFs fs;
1.2667 + User::LeaveIfError(fs.Connect());
1.2668 + CleanupClosePushL(fs);
1.2669 +
1.2670 + CFileMan* fm = CFileMan::NewL(fs);
1.2671 + CleanupStack::PushL(fm);
1.2672 +
1.2673 + TRAPD(err,TServerResources::InitialiseL());
1.2674 + TEST2(err,KErrNone);
1.2675 +
1.2676 + delete TServerResources::iInstallDirectory;
1.2677 + _LIT(KInstallFolder,"c:\\private\\12345678\\");
1.2678 + TServerResources::iInstallDirectory=(KInstallFolder()).AllocL();
1.2679 + TInt erro=fm->Delete(_L("c:\\private\\12345678\\*.*"));
1.2680 + //copy centrep.ini file to the install folder
1.2681 + _LIT(KSource,"z:\\private\\10202be9\\centrepcache.ini0");
1.2682 + _LIT(KDestination,"c:\\private\\12345678\\centrep.ini");
1.2683 + TRAP(err,CopyTestFilesL(*fm,KSource(),KDestination()));
1.2684 +
1.2685 + CCentRepSWIWatcher* swi=CCentRepSWIWatcher::NewL(fs);
1.2686 + TRAP(err,swi->FindChangedEntriesL(EFalse));
1.2687 + TEST2(err,KErrNone);
1.2688 +
1.2689 + delete swi;
1.2690 + TServerResources::Close();
1.2691 +
1.2692 + //delete the c file before we exit
1.2693 + fm->Delete(KDestination());
1.2694 +
1.2695 + CleanupStack::PopAndDestroy(3);
1.2696 + __UHEAP_MARKEND;
1.2697 + }
1.2698 +
1.2699 +/**
1.2700 +@SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4086
1.2701 +@SYMTestCaseDesc centralrepositorysrv.exe crashes and phone doesn't boot up
1.2702 +@SYMTestPriority High
1.2703 +@SYMTestActions Test merging two settings of different type, one type exist for
1.2704 +persist and one type for the new rom, when the type differes, we expect the
1.2705 +persist setting to be completely replaced by the rom.
1.2706 +@SYMTestExpectedResults The test must not panic or fail.
1.2707 +@SYMDEF PDEF141519
1.2708 +*/
1.2709 +LOCAL_C void PDEF141519L()
1.2710 + {
1.2711 + __UHEAP_MARK;
1.2712 +
1.2713 + RSettingsArray persist;
1.2714 + RSettingsArray newRom;
1.2715 + RArray<TUint32> deletedSettings;
1.2716 + //persist setting
1.2717 + TServerSetting a(0x10);
1.2718 + a.SetType(TServerSetting::EInt);
1.2719 + a.SetIntValue(100);
1.2720 + persist.OrderedInsertL(a);
1.2721 +
1.2722 + //new rom setting
1.2723 + TServerSetting b(0x10);
1.2724 + b.SetType(TServerSetting::EString);
1.2725 + TBuf8<5> buffer(_L8("abc"));
1.2726 + HBufC8* hbuf=buffer.AllocL();
1.2727 + b.SetStrValue(hbuf);
1.2728 + newRom.OrderedInsertL(b);
1.2729 +
1.2730 + User::LeaveIfError(persist.MergeArray(newRom,deletedSettings,ERomFlash));
1.2731 + TServerSetting* persistEntry=persist.Find(0x10);
1.2732 + TEST2(persistEntry->Key(),0x10);
1.2733 + TEST2(persistEntry->Type(),TServerSetting::EString);
1.2734 + const HBufC8* val=persistEntry->GetStrValue();
1.2735 + TEST2(val->Compare(buffer),0);
1.2736 +
1.2737 + persist.Close();
1.2738 + newRom.Close();
1.2739 +
1.2740 + __UHEAP_MARKEND;
1.2741 + }
1.2742 +
1.2743 +LOCAL_C void ConnectStartSuicideTransL(void)
1.2744 + {
1.2745 + const TUid KLargeReposUid1 ={0xcccccc00};
1.2746 + CRepository* repository=CRepository::NewL(KLargeReposUid1);
1.2747 + repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.2748 + }
1.2749 +
1.2750 +LOCAL_C TInt SuicidalTransThread(TAny*)
1.2751 + {
1.2752 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.2753 + if(!cleanup)
1.2754 + return KErrNoMemory;
1.2755 +
1.2756 + TRAP_IGNORE(ConnectStartSuicideTransL());
1.2757 + //purposely waiting to be killed
1.2758 + User::WaitForAnyRequest();
1.2759 + return 0;
1.2760 + }
1.2761 +
1.2762 +LOCAL_C void DEF143352L()
1.2763 + {
1.2764 + CleanupCDriveL();
1.2765 + __UHEAP_MARK;
1.2766 +
1.2767 + const TUid KLargeReposUid1 ={0xcccccc00};
1.2768 + //create on in this thread and start transaction too
1.2769 + CRepository* rep1=CRepository::NewL(KLargeReposUid1);
1.2770 + User::LeaveIfError(rep1->StartTransaction(CRepository::EConcurrentReadWriteTransaction));
1.2771 +
1.2772 + //create thread to connect, start transaction on the same repository as previous
1.2773 + RThread testThread;
1.2774 + _LIT(KThreadName1, "Martin");
1.2775 + testThread.Create(KThreadName1, SuicidalTransThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL);
1.2776 +
1.2777 + TRequestStatus requestStatus;
1.2778 + testThread.Logon(requestStatus);
1.2779 + testThread.Resume();
1.2780 +
1.2781 + //wait for the first client to complete the start transaction
1.2782 + User::After(1000000);
1.2783 +
1.2784 + //opening another big keyspace to force the eviction(cache size is 100K) both repository is about 78K in the heap
1.2785 + //cccccc03 is exactly the same as cccccc00
1.2786 + const TUid KLargeReposUid2 ={0xcccccc04};
1.2787 + CRepository* rep2=CRepository::NewL(KLargeReposUid2);
1.2788 +
1.2789 + //now kill the thread we have created
1.2790 + testThread.Kill(KErrDied);
1.2791 + User::WaitForRequest(requestStatus);
1.2792 + TEST2(requestStatus.Int(), KErrDied);
1.2793 +
1.2794 + //Wait for the session to be cleaned up
1.2795 + User::After(1000000);
1.2796 +
1.2797 + //now current test thread will retry the same connection
1.2798 + //at this stage server will panic with kern-exec 3
1.2799 + CRepository* rep4=CRepository::NewL(KLargeReposUid1);
1.2800 +
1.2801 + delete rep1;
1.2802 + delete rep2;
1.2803 + delete rep4;
1.2804 +
1.2805 + __UHEAP_MARKEND;
1.2806 + }
1.2807 +
1.2808 +LOCAL_C void FuncTestsL()
1.2809 + {
1.2810 + TheTest.Start(_L("DEF053500 - Central repository integer type key entries cannot handle hex values"));
1.2811 +
1.2812 + DEF053500L();
1.2813 +
1.2814 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-4015 DEF111734 - Central repository crashes when accessing a closed repository with active transaction "));
1.2815 + DEF111734L();
1.2816 +
1.2817 + TheTest.Next(_L("DEF054368 - MetaData value in CentRep setting is not optional"));
1.2818 + DEF054368L();
1.2819 +
1.2820 + TheTest.Next(_L("DEF055680 - Central repository find performance could be improved "));
1.2821 + DEF055680L();
1.2822 +
1.2823 + TheTest.Next(_L("INC054688 - Key based capabilities in ini-file crashes cenrep server "));
1.2824 + INC054688L();
1.2825 +
1.2826 + TheTest.Next(_L("DEF054632 - CenRep Initialisation default data does not work as expected"));
1.2827 + DEF054632L();
1.2828 +
1.2829 + TheTest.Next(_L("DEF055661 - Central Repository does not allow AlwaysFail to be set for access control. "));
1.2830 + DEF055661L();
1.2831 +
1.2832 + TheTest.Next(_L("DEF055267 - Can not insert more than 71 records into WapAccessPoint Table "));
1.2833 + DEF055267L();
1.2834 +
1.2835 + TheTest.Next(_L("INC056194 - NTT - Central Repository checks DefaultWriteAccessPolicy when cancelling notif "));
1.2836 + INC056194L();
1.2837 +
1.2838 + TheTest.Next(_L("DEF057145 - CenRepSrv KERN-EXEC3 when running CommDB test harness "));
1.2839 + DEF057145L();
1.2840 +
1.2841 + TheTest.Next(_L("DEF057778 - Central repository ResetAll can cause user Panic 190 "));
1.2842 + DEF057778L();
1.2843 +
1.2844 + TheTest.Next(_L("DEF057522 - Centralrepository security policy incorrect behaviour "));
1.2845 + DEF057522L();
1.2846 +
1.2847 + TheTest.Next(_L("DEF057999 - Creating and deleting the same setting in a transaction doesn't work "));
1.2848 + DEF057999L();
1.2849 +
1.2850 + TheTest.Next(_L("DEF057470 - Central repository lacks a range delete method "));
1.2851 + DEF057470L();
1.2852 +
1.2853 + TheTest.Next(_L("INC058229 - CInstallFileWatcher::ReadInstallDirL contains insufficient error handling "));
1.2854 + INC058229L();
1.2855 +
1.2856 + TheTest.Next(_L("DEF058900 - CentralRepository Notification section document needs update "));
1.2857 + DEF058900L();
1.2858 +
1.2859 + TheTest.Next(_L("DEF061087 - Central repository cannot handle more than one range policy "));
1.2860 + DEF061087L();
1.2861 +
1.2862 + TheTest.Next(_L("DEF060843 - [PSAudit] Lack of centralrep. data type checking could cause instability & bugs "));
1.2863 + DEF060843L();
1.2864 +
1.2865 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1433 INC069013 - Central repository panics the client when trying to read 8-bit descriptor with uneven length "));
1.2866 + INC069013L();
1.2867 +
1.2868 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1434 DEF070731 - Central repository doesn't handle corrupt .cre files correctly. "));
1.2869 + DEF070731L();
1.2870 +
1.2871 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1683 DEF084700 - UIF automated tests crash H4 board. "));
1.2872 + DEF084700L();
1.2873 +
1.2874 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1862 DEF089945: [AQP] CommitTransaction returns incorrect error code if Find~L methods run OOM "));
1.2875 + DEF089945L();
1.2876 +
1.2877 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3242 PDEF098500 - Backup to memory card causes phone freeze "));
1.2878 + PDEF098500();
1.2879 +
1.2880 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1884 DEF093855: CenRep cancels transactions if they exceed 5 seconds... "));
1.2881 + DEF093855L();
1.2882 +
1.2883 +
1.2884 +// When adding a new defect test, if you decide to reuse a repository that has already been used
1.2885 +// in another defect test, make sure you modify the existing test which uses the repository and
1.2886 +// add the cache delay after that test closes the repository. e.g. DEF055680L
1.2887 +
1.2888 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3477 PDEF106507 - Currupt installdir.bin file causes server to crash "));
1.2889 + PDEF106507L();
1.2890 +
1.2891 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3517 INC108803 - R3.2 stability problems: CentralRepositorySrv crash "));
1.2892 + INC108803L();
1.2893 +
1.2894 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3545 DEF109390: Centrep cache ini file corruption should not cause server crash. "));
1.2895 + DEF109390L();
1.2896 +
1.2897 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4024 DEF116043: Cenrep doesn't protect against overflows in sorting "));
1.2898 + DEF116043L();
1.2899 +
1.2900 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-4035 DEF117987: CenrepNotify handler does not leave/return error "));
1.2901 + DEF117987L();
1.2902 +
1.2903 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-4034 DEF117848: Centrep notifier handler does not check return codes "));
1.2904 + DEF117848L();
1.2905 +
1.2906 + TheTest.Next(_L(" @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4036 DEF118107: Central Repository Notification Handler flooded with notifications "));
1.2907 + DEF118107L();
1.2908 +
1.2909 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4037 DEF116629: CentralRepository internal merge function need to be refactored and documented"));
1.2910 + DEF116629L();
1.2911 +
1.2912 + TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4046 PDEF126904 - Ini-file parsing of Symbian provided central repository server crashes"));
1.2913 + PDEF126904L();
1.2914 + TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4081 DEF132807 - CObservable::ObserverSortOrder ordering algorithm is wrong "));
1.2915 + DEF132807L();
1.2916 +
1.2917 + TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4084 DEF136161: CenRep file timestamp is never intialised "));
1.2918 + DEF136161L();
1.2919 +
1.2920 + TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4085 PDEF139979: Central Repository: Trying to configure Central Repository cache with centrep.in "));
1.2921 + PDEF139979L();
1.2922 +
1.2923 + TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4086 PDEF141518: centralrepositorysrv.exe crashes and phone doesn't boot up "));
1.2924 + PDEF141519L();
1.2925 +
1.2926 + TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-CT-XXXX DEF143352: CentralRepository server crash in CObservable::RefreshTransactorAccessPolicies "));
1.2927 + DEF143352L();
1.2928 +
1.2929 + TheTest.End();
1.2930 + }
1.2931 +
1.2932 +LOCAL_C void MainL()
1.2933 + {
1.2934 + TheTest.Start(_L("Defect tests"));
1.2935 + CleanupCDriveL();
1.2936 +
1.2937 + FuncTestsL();
1.2938 +
1.2939 + TheTest.Next(_L("Clean out C: files"));
1.2940 + CleanupCDriveL();
1.2941 +
1.2942 + TheTest.End();
1.2943 + TheTest.Close();
1.2944 + }
1.2945 +
1.2946 +TInt E32Main()
1.2947 + {
1.2948 + //
1.2949 + // For the tests to work we need SID policing enforced plus the specific
1.2950 + // capabilities listed below.
1.2951 + //
1.2952 + // These are dependent on the capabilities set in the platform security
1.2953 + // repository test initialisation file 87654321.txt. If the content
1.2954 + // of that file changes then the following clauses may need to be
1.2955 + // updated.
1.2956 + //
1.2957 + if(!PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement) ||
1.2958 + !PlatSec::IsCapabilityEnforced(ECapabilityNetworkServices) ||
1.2959 + !PlatSec::IsCapabilityEnforced(ECapabilityDRM) ||
1.2960 + !PlatSec::IsCapabilityEnforced(ECapabilityLocalServices) ||
1.2961 + !PlatSec::IsCapabilityEnforced(ECapabilityCommDD))
1.2962 + {
1.2963 + TheTest.Start(_L("NOTE: Skipping tests due to incompatible PlatSec enforcement settings"));
1.2964 + TheTest.End();
1.2965 + TheTest.Close();
1.2966 + return 0;
1.2967 + }
1.2968 +
1.2969 + __UHEAP_MARK;
1.2970 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.2971 + if(!cleanup)
1.2972 + return KErrNoMemory;
1.2973 +
1.2974 + TRAPD(err, MainL());
1.2975 + if (err != KErrNone)
1.2976 + User::Panic(_L("Testing failed: "), err);
1.2977 +
1.2978 + delete cleanup;
1.2979 + __UHEAP_MARKEND;
1.2980 +
1.2981 + return 0;
1.2982 + }