os/persistentdata/persistentstorage/centralrepository/test/t_cenrep_transactions.cpp
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/centralrepository/test/t_cenrep_transactions.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2644 @@
1.4 +// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "t_cenrep_helper.h"
1.20 +#include <centralrepository.h>
1.21 +#include <e32test.h>
1.22 +#include <f32file.h>
1.23 +#include <bautils.h>
1.24 +#include "e32math.h"
1.25 +#include "srvparams.h"
1.26 +#include "transstate.h"
1.27 +#include "clientrequest.h"
1.28 +#include "panic.h"
1.29 +
1.30 +//#define Additional_Test
1.31 +
1.32 +using namespace NCentralRepositoryConstants;
1.33 +
1.34 +RTest TheTest(_L("Central Repository Transaction Tests"));
1.35 +
1.36 +const TUid KUidTestRepository = { 0x0000101 };
1.37 +
1.38 +//
1.39 +// Repository A
1.40 +//
1.41 +
1.42 +const TUint32 KUnprotectedSettingsMask = 0xFF000000 ;
1.43 +
1.44 +const TInt KThreadStackSize =0x2000; // 8k
1.45 +const TInt KThreadMinHeapSize =0x4000; // 16k
1.46 +const TInt KThreadMaxHeapSize =0xa000; // 60k
1.47 +
1.48 +const TUint32 KInt1 = 1;
1.49 +const TInt KInt1_InitialValue = 1;
1.50 +
1.51 +const TUint32 KReal1 = 2;
1.52 +const TReal KReal1_InitialValue = 2.732;
1.53 +const TUint32 KString8 = 5;
1.54 +const TUint32 KString16 = 6;
1.55 +_LIT(KString16_InitialValue, "test\\\"string\"");
1.56 +_LIT8(KString8_InitialValue, "test\\\"string\"");
1.57 +
1.58 +const TInt KInt2 = 3;
1.59 +const TInt KInt2_InitialValue = 20;
1.60 +const TUint32 KReal2 = 28;
1.61 +const TReal KReal2_InitialValue = 2.5;
1.62 +const TReal KReal2_SecondValue = 3.5;
1.63 +const TUint32 KNewString8 = 21;
1.64 +const TUint32 KNewString16 = 22;
1.65 +_LIT(KString16_InitialValue2, "another\\\"string\"");
1.66 +_LIT8(KString8_InitialValue2, "another\\\"string\"");
1.67 +
1.68 +_LIT(KString16_Small_Value, "te");
1.69 +_LIT8(KString8_Small_Value, "te");
1.70 +
1.71 +const TUint32 KMoveTarget = 0x02000001 ;
1.72 +const TUint32 KMoveSourceDoesntExist = 0x01000000 ;
1.73 +const TUint32 KMoveMask = 0xFF0000FF ;
1.74 +
1.75 +const TUint32 KInt3 = 10; //Ranged Policy Key
1.76 +const TInt KInt3_InitialValue = 34;
1.77 +const TUint32 KInt4 = 0x201; //Default Policy Key
1.78 +const TInt KInt4_InitialValue = 10;
1.79 +const TUint32 KInt5 = 0x1000001; //Single Policy Key
1.80 +const TInt KInt5_SecondValue = 123;
1.81 +///////////////////////////////////////////////////////////////////////////////////////
1.82 +///////////////////////////////////////////////////////////////////////////////////////
1.83 +//Test macroses and functions
1.84 +LOCAL_C void CheckL(TInt aValue, TInt aLine)
1.85 + {
1.86 + if(!aValue)
1.87 + {
1.88 + CleanupCDriveL();
1.89 + TheTest(EFalse, aLine);
1.90 + }
1.91 + }
1.92 +LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine)
1.93 + {
1.94 + if(aValue != aExpected)
1.95 + {
1.96 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.97 + CleanupCDriveL();
1.98 + TheTest(EFalse, aLine);
1.99 + }
1.100 + }
1.101 +#define TEST(arg) ::CheckL((arg), __LINE__)
1.102 +#define TEST2(aValue, aExpected) ::CheckL(aValue, aExpected, __LINE__)
1.103 +
1.104 +///////////////////////////////////////////////////////////////////////////////////////
1.105 +///////////////////////////////////////////////////////////////////////////////////////
1.106 +
1.107 +typedef void (*TRepositoryFunc)(CRepository&);
1.108 +
1.109 +void ChangeByCreate(CRepository& aRep)
1.110 + {
1.111 + TInt r;
1.112 + // Create a setting outside of a transaction
1.113 + r = aRep.Create(KReal2, KReal2_InitialValue);
1.114 + TEST2(r, KErrNone);
1.115 + // confirm setting created
1.116 + TReal value;
1.117 + r = aRep.Get(KReal2, value);
1.118 + TEST2(r, KErrNone);
1.119 + TEST(value == KReal2_InitialValue);
1.120 + }
1.121 +
1.122 +void ChangeBySet(CRepository& aRep)
1.123 + {
1.124 + TInt r;
1.125 + // Set a value outside of a transaction
1.126 + r = aRep.Set(KReal2, KReal2_SecondValue);
1.127 + TEST2(r, KErrNone);
1.128 + // confirm value changed
1.129 + TReal value;
1.130 + r = aRep.Get(KReal2, value);
1.131 + TEST2(r, KErrNone);
1.132 + TEST(value == KReal2_SecondValue);
1.133 + }
1.134 +
1.135 +void ChangeByDelete(CRepository& aRep)
1.136 + {
1.137 + TInt r;
1.138 + // Delete a setting outside of a transaction
1.139 + r = aRep.Delete(KReal2);
1.140 + TEST2(r, KErrNone);
1.141 + // confirm it's deleted
1.142 + TReal value;
1.143 + r = aRep.Get(KReal2, value);
1.144 + TEST2(r, KErrNotFound);
1.145 + }
1.146 +
1.147 +void ChangeByTransaction(CRepository& aRep)
1.148 + {
1.149 + TInt r;
1.150 + TUint32 keyInfo;
1.151 +
1.152 + // Lock should prevent ERead/WriteTransactions from being able to start from
1.153 + // within function CommittingChangesFailsOtherTransactions.
1.154 + r = aRep.StartTransaction(CRepository::EReadWriteTransaction);
1.155 + TEST2(r, KErrLocked);
1.156 + r = aRep.StartTransaction(CRepository::EReadTransaction);
1.157 + TEST2(r, KErrLocked);
1.158 +
1.159 + // Concurrent Read/Write transactions can be opened at any time
1.160 + r = aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.161 + TEST2(r, KErrNone);
1.162 + r = TransactionState(&aRep);
1.163 + TEST2(r, EConcurrentReadWriteTransaction);
1.164 +
1.165 + // Create a setting within transaction
1.166 + r = aRep.Create(KReal2, KReal2_InitialValue);
1.167 + TEST2(r, KErrNone);
1.168 + // confirm setting created
1.169 + TReal value;
1.170 + r = aRep.Get(KReal2, value);
1.171 + TEST2(r, KErrNone);
1.172 + TEST(value == KReal2_InitialValue);
1.173 +
1.174 + r = aRep.CommitTransaction(keyInfo);
1.175 + TEST2(r, KErrNone);
1.176 + TEST2(keyInfo, 1); // 1 successful change
1.177 +
1.178 + // re-confirm setting is still there
1.179 + r = aRep.Get(KReal2, value);
1.180 + TEST2(r, KErrNone);
1.181 + TEST(value == KReal2_InitialValue);
1.182 + }
1.183 +
1.184 +// checking that async start and commit, with WaitForRequest do same as ChangeByTransaction
1.185 +void ChangeByAsyncTransaction(CRepository& aRep)
1.186 + {
1.187 + TInt r;
1.188 + CRepository::TTransactionKeyInfoBuf keyInfoBuf;
1.189 + TRequestStatus status;
1.190 +
1.191 + // Lock should prevent ERead/WriteTransactions from being able to start from
1.192 + // within function CommittingChangesFailsOtherTransactions.
1.193 + aRep.StartTransaction(CRepository::EReadWriteTransaction, status);
1.194 + User::WaitForRequest(status);
1.195 + TEST2(status.Int(), KErrLocked);
1.196 + aRep.StartTransaction(CRepository::EReadTransaction, status);
1.197 + User::WaitForRequest(status);
1.198 + TEST2(status.Int(), KErrLocked);
1.199 +
1.200 + // Concurrent Read/Write transactions can be opened at any time
1.201 + aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction, status);
1.202 + // can't predict whether status will be KRequestPending at this time, so don't check
1.203 + User::WaitForRequest(status);
1.204 + TEST2(status.Int(), KErrNone);
1.205 + r = TransactionState(&aRep);
1.206 + TEST2(r, EConcurrentReadWriteTransaction);
1.207 +
1.208 + // Create a setting within transaction
1.209 + r = aRep.Create(KReal2, KReal2_InitialValue);
1.210 + TEST2(r, KErrNone);
1.211 + // confirm setting created
1.212 + TReal value;
1.213 + r = aRep.Get(KReal2, value);
1.214 + TEST2(r, KErrNone);
1.215 + TEST(value == KReal2_InitialValue);
1.216 +
1.217 + aRep.CommitTransaction(keyInfoBuf, status);
1.218 + User::WaitForRequest(status);
1.219 + TEST2(status.Int(), KErrNone);
1.220 + TEST2(keyInfoBuf(), 1); // 1 successful change
1.221 +
1.222 + // re-confirm setting is still there
1.223 + r = aRep.Get(KReal2, value);
1.224 + TEST2(r, KErrNone);
1.225 + TEST(value == KReal2_InitialValue);
1.226 + }
1.227 +
1.228 +void ChangeByReset(CRepository& aRep)
1.229 + {
1.230 + TInt r;
1.231 + // Delete a setting outside of a transaction
1.232 + r = aRep.Reset(KReal2);
1.233 + TEST2(r, KErrNone);
1.234 + // confirm it's reset (should be deleted)
1.235 + TReal value;
1.236 + r = aRep.Get(KReal2, value);
1.237 + TEST2(r, KErrNotFound);
1.238 + }
1.239 +
1.240 +void ChangeByResetAll(CRepository& aRep)
1.241 + {
1.242 + TInt r;
1.243 + // Delete a setting outside of a transaction
1.244 + r = aRep.Reset();
1.245 + TEST2(r, KErrNone);
1.246 + // confirm it's reset (should be deleted)
1.247 + TReal value;
1.248 + r = aRep.Get(KReal2, value);
1.249 + TEST2(r, KErrNotFound);
1.250 + }
1.251 +
1.252 +// tests that changes made by calling ChangeFunc with aCommittingRepository fail active
1.253 +// transactions with reason KErrLocked, and correctly discard changes
1.254 +LOCAL_C void CallFuncCheckOtherTransactionsFail(TRepositoryFunc ChangeFunc, CRepository& aCommittingRepository)
1.255 + {
1.256 + TInt r;
1.257 + TUint32 keyInfo;
1.258 + CRepository* repository1;
1.259 + CRepository* repository2;
1.260 +
1.261 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.262 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));
1.263 +
1.264 + // Start two types of transaction
1.265 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.266 + TEST2(r, KErrNone);
1.267 + r = repository2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.268 + TEST2(r, KErrNone);
1.269 +
1.270 + // check transactions haven't failed yet.
1.271 + r = TransactionState(repository1);
1.272 + TEST2(r, EReadWriteTransaction);
1.273 + r = TransactionState(repository2);
1.274 + TEST2(r, EConcurrentReadWriteTransaction);
1.275 +
1.276 + // create a value in repository2's transaction and check it is there
1.277 + r = repository2->Create(KInt1, KInt1_InitialValue);
1.278 + TEST2(r, KErrNone);
1.279 + TInt value;
1.280 + r = repository2->Get(KInt1, value);
1.281 + TEST2(r, KErrNone);
1.282 + TEST(value == KInt1_InitialValue);
1.283 +
1.284 + (*ChangeFunc)(aCommittingRepository);
1.285 +
1.286 + // check transactions have now failed
1.287 + r = TransactionState(repository1);
1.288 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.289 + r = TransactionState(repository2);
1.290 + TEST2(r, EConcurrentReadWriteTransaction | EFailedBit);
1.291 +
1.292 + // operations should abort after failing
1.293 + r = repository2->Get(KInt1, value);
1.294 + TEST2(r, KErrAbort);
1.295 + r = repository1->Set(KInt1, value);
1.296 + TEST2(r, KErrAbort);
1.297 +
1.298 + // commits should fail with KErrLocked
1.299 + r = repository2->CommitTransaction(keyInfo);
1.300 + TEST2(r, KErrLocked);
1.301 + TEST2(keyInfo, KUnspecifiedKey);
1.302 + r = repository1->CommitTransaction(keyInfo);
1.303 + TEST2(r, KErrLocked);
1.304 + TEST2(keyInfo, KUnspecifiedKey);
1.305 +
1.306 + // integer should not be persistent
1.307 + r = repository2->Get(KInt1, value);
1.308 + TEST2(r, KErrNotFound);
1.309 +
1.310 + CleanupStack::PopAndDestroy(repository2);
1.311 + CleanupStack::PopAndDestroy(repository1);
1.312 + }
1.313 +
1.314 +/**
1.315 +@SYMTestCaseID SYSLIB-CENREP-CT-0150
1.316 +@SYMTestCaseDesc Check committing changes causes other transactions to fail.
1.317 +@SYMTestPriority High
1.318 +@SYMTestActions Run a series of commands that modify repository, check they fail active transactions.
1.319 + Start concurrent read write transaction and try to create and get values using other repository.
1.320 +@SYMTestExpectedResults The test should not fail with any panics
1.321 +@SYMPREQ PREQ752
1.322 +*/
1.323 +LOCAL_C void CommittingChangesFailsOtherTransactionsL()
1.324 + {
1.325 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0150 "));
1.326 + CRepository* repository;
1.327 +
1.328 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));
1.329 +
1.330 + repository->Reset();
1.331 +
1.332 + // non-transaction create should fail active transactions
1.333 + CallFuncCheckOtherTransactionsFail(ChangeByCreate, *repository);
1.334 +
1.335 + // non-transaction set should fail active transactions
1.336 + CallFuncCheckOtherTransactionsFail(ChangeBySet, *repository);
1.337 +
1.338 + // non-transaction delete should fail active transactions
1.339 + CallFuncCheckOtherTransactionsFail(ChangeByDelete, *repository);
1.340 +
1.341 + // transaction commit with changes should fail active transactions
1.342 + CallFuncCheckOtherTransactionsFail(ChangeByTransaction, *repository);
1.343 +
1.344 + ChangeByDelete(*repository); // just to ready for next test
1.345 +
1.346 + // async started and committed transaction with changes should fail active transactions
1.347 + CallFuncCheckOtherTransactionsFail(ChangeByAsyncTransaction, *repository);
1.348 +
1.349 + // individual reset that has an effect should fail active transactions
1.350 + CallFuncCheckOtherTransactionsFail(ChangeByReset, *repository);
1.351 +
1.352 + ChangeByCreate(*repository); // just to ready for next test
1.353 +
1.354 + // reset all should fail active transactions
1.355 + CallFuncCheckOtherTransactionsFail(ChangeByResetAll, *repository);
1.356 +
1.357 + CleanupStack::PopAndDestroy(repository);
1.358 + }
1.359 +
1.360 +void NoChangeByTransactionCreateDelete(CRepository& aRep)
1.361 + {
1.362 + TInt r;
1.363 + TUint32 keyInfo;
1.364 + // Concurrent Read/Write transactions can be opened at any time
1.365 + r = aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.366 + TEST2(r, KErrNone);
1.367 + r = TransactionState(&aRep);
1.368 + TEST2(r, EConcurrentReadWriteTransaction);
1.369 + // deleting the setting that was just added should result in no change when committing:
1.370 + ChangeByCreate(aRep);
1.371 + ChangeByDelete(aRep);
1.372 + r = aRep.CommitTransaction(keyInfo);
1.373 + TEST2(r, KErrNone);
1.374 + TEST2(keyInfo, 0); // no changes
1.375 + }
1.376 +
1.377 +void NoChangeByTransactionSetSameValue(CRepository& aRep)
1.378 + {
1.379 + TInt r;
1.380 + TUint32 keyInfo;
1.381 + // Concurrent Read/Write transactions can be opened at any time
1.382 + r = aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.383 + TEST2(r, KErrNone);
1.384 + r = TransactionState(&aRep);
1.385 + TEST2(r, EConcurrentReadWriteTransaction);
1.386 + // changing setting to the value it already has should result in no change when committing:
1.387 + ChangeBySet(aRep);
1.388 + r = aRep.CommitTransaction(keyInfo);
1.389 + TEST2(r, KErrNone);
1.390 + TEST2(keyInfo, 0); // no changes
1.391 + }
1.392 +
1.393 +void NoChangeByReadTransaction(CRepository& aRep)
1.394 + {
1.395 + TInt r;
1.396 + TUint32 keyInfo;
1.397 + // Read transactions can be opened now because there is no EReadWriteTransaction open
1.398 + r = aRep.StartTransaction(CRepository::EReadTransaction);
1.399 + TEST2(r, KErrNone);
1.400 + r = TransactionState(&aRep);
1.401 + TEST2(r, EReadTransaction);
1.402 + // Getting a value should result in no change when committing:
1.403 + TReal value;
1.404 + r = aRep.Get(KReal2, value);
1.405 + TEST2(r, KErrNone);
1.406 + TEST(value == KReal2_InitialValue);
1.407 + r = aRep.CommitTransaction(keyInfo);
1.408 + TEST2(r, KErrNone);
1.409 + TEST2(keyInfo, 0); // no changes
1.410 + }
1.411 +
1.412 +void NoChangeByEmptyWriteTransaction(CRepository& aRep)
1.413 + {
1.414 + TInt r;
1.415 + TUint32 keyInfo;
1.416 + // can't start an EReadWriteTransaction because a ReadTransaction is active
1.417 + r = aRep.StartTransaction(CRepository::EReadWriteTransaction);
1.418 + TEST2(r, KErrLocked);
1.419 + // Concurrent Read/Write transactions can be opened at any time
1.420 + r = aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.421 + TEST2(r, KErrNone);
1.422 + r = TransactionState(&aRep);
1.423 + TEST2(r, EConcurrentReadWriteTransaction);
1.424 + // make no changes before committing
1.425 + r = aRep.CommitTransaction(keyInfo);
1.426 + TEST2(r, KErrNone);
1.427 + TEST2(keyInfo, 0); // no changes
1.428 + }
1.429 +
1.430 +// tests that changes made by calling ChangeFunc with aCommittingRepository
1.431 +// do not fail active transactions. Must Reset before calling this.
1.432 +LOCAL_C void CallFuncCheckOtherTransactionsDoNotFail(TRepositoryFunc ChangeFunc, CRepository& aCommittingRepository)
1.433 + {
1.434 + TInt r;
1.435 + CRepository::TTransactionKeyInfoBuf keyInfoBuf;
1.436 + TUint32 keyInfo;
1.437 + TRequestStatus status;
1.438 + CRepository* repository1;
1.439 + CRepository* repository2;
1.440 +
1.441 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.442 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));
1.443 +
1.444 + // Start two types of transaction and wait for completion
1.445 + r = repository1->StartTransaction(CRepository::EReadTransaction);
1.446 + TEST2(r, KErrNone);
1.447 + repository2->StartTransaction(CRepository::EConcurrentReadWriteTransaction, status);
1.448 + User::WaitForRequest(status);
1.449 + TEST2(status.Int(), KErrNone);
1.450 +
1.451 + // create values in repository2's transaction cache
1.452 + r = repository2->Create(KNewString8, KString8_InitialValue);
1.453 + TEST2(r, KErrNone);
1.454 + r = repository2->Create(KNewString16, KString16_InitialValue);
1.455 + TEST2(r, KErrNone);
1.456 +
1.457 + // check transactions not failed
1.458 + r = TransactionState(repository1);
1.459 + TEST2(r, EReadTransaction);
1.460 + r = TransactionState(repository2);
1.461 + TEST2(r, EConcurrentReadWriteTransaction);
1.462 +
1.463 + (*ChangeFunc)(aCommittingRepository);
1.464 +
1.465 + // create setting in repository 1's cache
1.466 + r = repository1->Create(KInt2, KInt2_InitialValue);
1.467 + TEST2(r, KErrNone);
1.468 +
1.469 + // check transactions not failed & Read upgraded to ReadWrite
1.470 + r = TransactionState(repository1);
1.471 + TEST2(r, EReadWriteTransaction);
1.472 + r = TransactionState(repository2);
1.473 + TEST2(r, EConcurrentReadWriteTransaction);
1.474 +
1.475 + // commit repository2 asynchronously
1.476 + repository2->CommitTransaction(keyInfoBuf, status);
1.477 + User::WaitForRequest(status);
1.478 + TEST2(status.Int(), KErrNone);
1.479 + TEST2(keyInfoBuf(), 2); // 2 successful changes
1.480 +
1.481 + // check transaction2 finished, transaction 1 failed
1.482 + r = TransactionState(repository1);
1.483 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.484 + r = TransactionState(repository2);
1.485 + TEST2(r, ENoTransaction);
1.486 +
1.487 + // operations on repository 1 should abort after failing
1.488 + TInt intValue;
1.489 + r = repository1->Get(KInt1, intValue);
1.490 + TEST2(r, KErrAbort);
1.491 + r = repository1->Set(KInt1, intValue);
1.492 + TEST2(r, KErrAbort);
1.493 +
1.494 + // commit of repository 1 should fail with KErrLocked
1.495 + r = repository1->CommitTransaction(keyInfo);
1.496 + TEST2(r, KErrLocked);
1.497 + TEST2(keyInfo, KUnspecifiedKey);
1.498 +
1.499 + // check changes by repository 2 are still present
1.500 + TBuf8<40> buf8Value;
1.501 + TBuf16<40> buf16Value;
1.502 +
1.503 + r = repository2->Get(KNewString8, buf8Value);
1.504 + TEST2(r, KErrNone);
1.505 + TEST(buf8Value == KString8_InitialValue);
1.506 + r = repository2->Get(KNewString16, buf16Value);
1.507 + TEST2(r, KErrNone);
1.508 + TEST(buf16Value == KString16_InitialValue);
1.509 +
1.510 + CleanupStack::PopAndDestroy(repository2);
1.511 + CleanupStack::PopAndDestroy(repository1);
1.512 + }
1.513 +
1.514 +/**
1.515 +@SYMTestCaseID SYSLIB-CENREP-CT-0151
1.516 +@SYMTestCaseDesc Check committing no changes (incl. setting same value) does not cause other transactions to fail.
1.517 +@SYMTestPriority High
1.518 +@SYMTestActions Run a series of commands that modify repository, check they fail active transactions.
1.519 + Start concurrent read write transaction and try to create and get values using other repository.
1.520 +@SYMTestExpectedResults The test should not fail with any panics
1.521 +@SYMPREQ PREQ752
1.522 +*/
1.523 +LOCAL_C void CommittingNoChangesDoesNotFailOtherTransactionsL()
1.524 + {
1.525 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0151 "));
1.526 + CRepository* repository;
1.527 +
1.528 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));
1.529 +
1.530 + // creating and deleting the same setting in the same transaction should have no effect
1.531 + repository->Reset();
1.532 + CallFuncCheckOtherTransactionsDoNotFail(NoChangeByTransactionCreateDelete, *repository);
1.533 +
1.534 + // changing a setting to the same value in a transaction should have no effect
1.535 + repository->Reset();
1.536 + ChangeByCreate(*repository);
1.537 + ChangeBySet(*repository);
1.538 + CallFuncCheckOtherTransactionsDoNotFail(NoChangeByTransactionSetSameValue, *repository);
1.539 +
1.540 + // committing a Read transaction should have no effect
1.541 + repository->Reset();
1.542 + ChangeByCreate(*repository);
1.543 + CallFuncCheckOtherTransactionsDoNotFail(NoChangeByReadTransaction, *repository);
1.544 +
1.545 + // committing an empty transaction should have no effect
1.546 + repository->Reset();
1.547 + CallFuncCheckOtherTransactionsDoNotFail(NoChangeByEmptyWriteTransaction, *repository);
1.548 +
1.549 + CleanupStack::PopAndDestroy(repository);
1.550 +
1.551 + // restart session and check values are indeed saved
1.552 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));
1.553 +
1.554 + TInt r;
1.555 + TBuf8<40> buf8Value;
1.556 + TBuf16<40> buf16Value;
1.557 + r = repository->Get(KNewString8, buf8Value);
1.558 + TEST2(r, KErrNone);
1.559 + TEST(buf8Value == KString8_InitialValue);
1.560 + r = repository->Get(KNewString16, buf16Value);
1.561 + TEST2(r, KErrNone);
1.562 + TEST(buf16Value == KString16_InitialValue);
1.563 + // final cleanup
1.564 + repository->Reset();
1.565 +
1.566 + CleanupStack::PopAndDestroy(repository);
1.567 + }
1.568 +
1.569 +/**
1.570 +@SYMTestCaseID SYSLIB-CENREP-CT-0152
1.571 +@SYMTestCaseDesc Testing creates in a read write transaction
1.572 +@SYMTestPriority High
1.573 +@SYMTestActions Starts a read write transaction which creates values for KInt1, KReal1, KString8 and KString16
1.574 +@SYMTestExpectedResults The test should not fail with any panics
1.575 +@SYMPREQ PREQ752
1.576 +*/
1.577 +LOCAL_C void CreateValueUsingTransactionL()
1.578 + {
1.579 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0152 "));
1.580 + TInt r;
1.581 + TUint32 errorId;
1.582 +
1.583 + CRepository* repository;
1.584 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));
1.585 +
1.586 + // Begin read write transaction
1.587 + r = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.588 + TEST2(r, KErrNone);
1.589 +
1.590 + r = repository->Create(KInt1, KInt1_InitialValue);
1.591 + TEST2(r, KErrNone);
1.592 +
1.593 + r = repository->Create(KReal1, KReal1_InitialValue);
1.594 + TEST2(r, KErrNone);
1.595 +
1.596 + r = repository->Create(KString8, KString8_InitialValue);
1.597 + TEST2(r, KErrNone);
1.598 +
1.599 + r = repository->Create(KString16, KString16_InitialValue);
1.600 + TEST2(r, KErrNone);
1.601 +
1.602 + // Commit transaction
1.603 + r = repository->CommitTransaction(errorId);
1.604 + TEST2(r, KErrNone);
1.605 + // Test for the value of errorId for a successful read write transaction = 4 changes
1.606 + TEST2(errorId, 4);
1.607 +
1.608 + CleanupStack::PopAndDestroy(repository);
1.609 +
1.610 + }
1.611 +
1.612 +/**
1.613 +@SYMTestCaseID SYSLIB-CENREP-CT-0153
1.614 +@SYMTestCaseDesc Testing state and rollback in a transaction
1.615 +@SYMTestPriority High
1.616 +@SYMTestActions Use both transactionstate and failtransaction while being in a transaction and not in a transaction.
1.617 + Check on the state and test to see if rollback occurs when required.
1.618 +@SYMTestExpectedResults The test should not fail with any panics
1.619 +@SYMPREQ PREQ752
1.620 +*/
1.621 +LOCAL_C void TransactionStateAndRollBackL()
1.622 + {
1.623 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0153 "));
1.624 + TInt r;
1.625 + TUint32 errorId;
1.626 + TReal getValue;
1.627 +
1.628 + CRepository* repository;
1.629 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));
1.630 +
1.631 + r = TransactionState(repository);
1.632 + TEST2(r, ENoTransaction);
1.633 +
1.634 + // Try to fail transaction without being in a transaction
1.635 + repository->FailTransaction();
1.636 +
1.637 + r = TransactionState(repository);
1.638 + TEST2(r, ENoTransaction);
1.639 +
1.640 + // Begin concurrent read write transaction
1.641 + r = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.642 + TEST2(r, KErrNone);
1.643 +
1.644 + r = TransactionState(repository);
1.645 + TEST2(r, EReadWriteTransaction);
1.646 +
1.647 + r = repository->Create(KReal2, KReal2_InitialValue);
1.648 + TEST2(r, KErrNone);
1.649 +
1.650 + r = repository->Get(KReal2, getValue);
1.651 + TEST(getValue == KReal2_InitialValue);
1.652 + TEST2(r, KErrNone);
1.653 +
1.654 + // Fail transaction should roll back transaction i.e. Create KReal2 should not work.
1.655 + repository->FailTransaction();
1.656 +
1.657 + r = TransactionState(repository);
1.658 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.659 +
1.660 + // Commit transaction
1.661 + r = repository->CommitTransaction(errorId);
1.662 + TEST2(r, KErrAbort);
1.663 + // Test the value of errorId for a failed read write transaction
1.664 + TEST2(errorId, KUnspecifiedKey);
1.665 +
1.666 + // Try to get a value which should not exist as transaction failed
1.667 + r = repository->Get(KReal2, getValue);
1.668 + TEST2(r, KErrNotFound);
1.669 +
1.670 + r = TransactionState(repository);
1.671 + TEST2(r, ENoTransaction);
1.672 +
1.673 + r = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.674 + TEST2(r, KErrNone);
1.675 +
1.676 + r = repository->Create(KReal2, KReal2_InitialValue);
1.677 + TEST2(r, KErrNone);
1.678 +
1.679 + repository->RollbackTransaction();
1.680 +
1.681 + // Try to get a value which should not exist as transaction rolled back
1.682 + r = repository->Get(KReal2, getValue);
1.683 + TEST2(r, KErrNotFound);
1.684 +
1.685 + // Transaction state should be ENoTransaction due to call to RollbackTransaction()
1.686 + r = TransactionState(repository);
1.687 + TEST2(r, ENoTransaction);
1.688 +
1.689 + // Begin read transaction
1.690 + r = repository->StartTransaction(CRepository::EReadTransaction);
1.691 + TEST2(r, KErrNone);
1.692 +
1.693 + r = TransactionState(repository);
1.694 + TEST2(r, EReadTransaction);
1.695 +
1.696 + r = repository->Get(KReal1, getValue);
1.697 + TEST2(r, KErrNone);
1.698 + TEST(getValue == KReal1_InitialValue);
1.699 +
1.700 + // Fail transaction
1.701 + repository->FailTransaction();
1.702 +
1.703 + r = TransactionState(repository);
1.704 + TEST2(r, EReadTransaction | EFailedBit);
1.705 +
1.706 + // Commit transaction
1.707 + r = repository->CommitTransaction(errorId);
1.708 + TEST2(r, KErrAbort);
1.709 +
1.710 + r = TransactionState(repository);
1.711 + TEST2(r, ENoTransaction);
1.712 +
1.713 + // Begin another read transaction
1.714 + r = repository->StartTransaction(CRepository::EReadTransaction);
1.715 + TEST2(r, KErrNone);
1.716 +
1.717 + r = repository->Get(KReal1, getValue);
1.718 + TEST2(r, KErrNone);
1.719 + TEST(getValue == KReal1_InitialValue);
1.720 +
1.721 + r = TransactionState(repository);
1.722 + TEST2(r, EReadTransaction);
1.723 +
1.724 + // Perform Create in a ReadTransaction as upgrade has occured
1.725 + r = repository->Create(KReal2, KReal2_InitialValue);
1.726 + TEST2(r, KErrNone);
1.727 +
1.728 + // The state should be updated to be EInReadWriteTransaction
1.729 + r = TransactionState(repository);
1.730 + TEST2(r, EReadWriteTransaction);
1.731 +
1.732 + r = repository->Get(KReal2, getValue);
1.733 + TEST2(r, KErrNone);
1.734 +
1.735 + // Commit transaction
1.736 + r = repository->CommitTransaction(errorId);
1.737 + TEST2(r, KErrNone);
1.738 +
1.739 + // Delete KReal2 to reset available test case variables
1.740 + r = repository->Delete(KReal2);
1.741 + TEST2(r, KErrNone);
1.742 +
1.743 + r = TransactionState(repository);
1.744 + TEST2(r, ENoTransaction);
1.745 +
1.746 + CleanupStack::PopAndDestroy(repository);
1.747 + }
1.748 +
1.749 +LOCAL_C void StartTransactionPanicConditionsL()
1.750 + {
1.751 + TInt r;
1.752 + TUint32 errorId;
1.753 +
1.754 + CRepository* repository1;
1.755 +
1.756 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.757 +
1.758 + // Begin read write transaction
1.759 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.760 + TEST2(r, KErrNone);
1.761 +
1.762 + // This should panic can't start second transaction in one session
1.763 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.764 + TEST2(r, KErrNone);
1.765 +
1.766 + // Commit transaction
1.767 + r = repository1->CommitTransaction(errorId);
1.768 + TEST2(r, KErrNone);
1.769 +
1.770 + CleanupStack::PopAndDestroy(repository1);
1.771 + }
1.772 +
1.773 +LOCAL_C TInt TestStartTransactionPanics(TAny* /*aData*/)
1.774 + {
1.775 + __UHEAP_MARK;
1.776 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.777 + if(!cleanup)
1.778 + return KErrNoMemory;
1.779 +
1.780 + TRAPD(err, StartTransactionPanicConditionsL());
1.781 +
1.782 + // Won't get here but add this line to get rid of ARMV5 warning
1.783 + TEST2(err, KErrNone);
1.784 +
1.785 + delete cleanup;
1.786 + __UHEAP_MARKEND;
1.787 +
1.788 + return (KErrNone);
1.789 + }
1.790 +
1.791 +/**
1.792 +@SYMTestCaseID SYSLIB-CENREP-CT-0154
1.793 +@SYMTestCaseDesc Testing valid panics while using StartTransaction
1.794 +@SYMTestPriority High
1.795 +@SYMTestActions Start a separate thread and within that thread try to start transaction twice
1.796 +@SYMTestExpectedResults The thread should exit with the exit type EExitPanic and exit reason EStartAlreadyInTransaction
1.797 +@SYMPREQ PREQ752
1.798 +*/
1.799 +LOCAL_C void TransactionPanicConditionsThread()
1.800 + {
1.801 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0154 "));
1.802 + TBool jitEnabled = User::JustInTime();
1.803 + User::SetJustInTime(EFalse);
1.804 +
1.805 + TRequestStatus status;
1.806 +
1.807 + _LIT(KName, "Transaction_Panic_Thread");
1.808 +
1.809 + RThread thread;
1.810 + TInt rc = thread.Create(KName,TestStartTransactionPanics,KThreadStackSize,KThreadMinHeapSize,KThreadMaxHeapSize,NULL);
1.811 +
1.812 + TEST2(rc,KErrNone);
1.813 +
1.814 + thread.Logon(status);
1.815 + thread.Resume();
1.816 +
1.817 + User::WaitForRequest(status);
1.818 +
1.819 + // Should result in a EExitPanic exit type and an EStartAlreadyInTransaction exit reason
1.820 + TEST2(thread.ExitType(), EExitPanic);
1.821 + TEST2(thread.ExitReason(), EStartAlreadyInTransaction);
1.822 +
1.823 + thread.Close();
1.824 +
1.825 + User::SetJustInTime(jitEnabled);
1.826 + }
1.827 +
1.828 +LOCAL_C void CommitTransactionPanicConditionL()
1.829 + {
1.830 + TInt r;
1.831 + TUint32 errorId;
1.832 +
1.833 + CRepository* repository1;
1.834 +
1.835 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.836 +
1.837 + // Commit transaction when there is not transaction should cause a panic
1.838 + r = repository1->CommitTransaction(errorId);
1.839 + TEST2(r, KErrNone);
1.840 +
1.841 + CleanupStack::PopAndDestroy(repository1);
1.842 + }
1.843 +
1.844 +
1.845 +LOCAL_C TInt TestCommitTransactionPanics(TAny* /*aData*/)
1.846 + {
1.847 + __UHEAP_MARK;
1.848 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.849 + if(!cleanup)
1.850 + return KErrNoMemory;
1.851 +
1.852 + TRAPD(err,CommitTransactionPanicConditionL());
1.853 +
1.854 + // Won't get here but add this line to get rid of ARMV5 warning
1.855 + TEST2(err, KErrNone);
1.856 +
1.857 + delete cleanup;
1.858 + __UHEAP_MARKEND;
1.859 + return (KErrNone);
1.860 + }
1.861 +
1.862 +/**
1.863 +@SYMTestCaseID SYSLIB-CENREP-CT-0155
1.864 +@SYMTestCaseDesc Testing valid panics while using CommitTransaction
1.865 +@SYMTestPriority High
1.866 +@SYMTestActions Start a separate thread and within that thread try to commit a transaction without being in one
1.867 +@SYMTestExpectedResults The thread should exit with the exit type EExitPanic and the exit reason ECommitNotInTransaction
1.868 +@SYMPREQ PREQ752
1.869 +*/
1.870 +LOCAL_C void CommitTransactionPanicConditionsThread()
1.871 + {
1.872 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0155 "));
1.873 + TBool jitEnabled = User::JustInTime();
1.874 + User::SetJustInTime(EFalse);
1.875 +
1.876 + TRequestStatus status;
1.877 +
1.878 + _LIT(KName, "Commit_Transaction_Panic_Thread");
1.879 +
1.880 + RThread thread;
1.881 + TInt rc = thread.Create(KName,TestCommitTransactionPanics,KThreadStackSize,KThreadMinHeapSize,KThreadMaxHeapSize,NULL);
1.882 +
1.883 + TEST2(rc,KErrNone);
1.884 +
1.885 + thread.Logon(status);
1.886 + thread.Resume();
1.887 +
1.888 + User::WaitForRequest(status);
1.889 +
1.890 + // Should result in a EExitPanic exit type and an ECommitNotInTransaction exit reason
1.891 + TEST2(thread.ExitType(), EExitPanic);
1.892 + TEST2(thread.ExitReason(), ECommitNotInTransaction);
1.893 +
1.894 + thread.Close();
1.895 +
1.896 + User::SetJustInTime(jitEnabled);
1.897 + }
1.898 +
1.899 +LOCAL_C void LeaveWithCleanupRollbackTransactionPushL(CRepository& aRepository)
1.900 + {
1.901 + TInt r = TransactionState(&aRepository);
1.902 + TEST2(r, CRepository::EReadWriteTransaction);
1.903 +
1.904 + aRepository.CleanupRollbackTransactionPushL();
1.905 +
1.906 + // Purposely leave in a transaction...
1.907 + User::LeaveNoMemory();
1.908 +
1.909 + // this code should never be reached...
1.910 + TEST(EFalse);
1.911 + // ...but if it did we'd have to cleanup the PushL
1.912 + CleanupStack::Pop();
1.913 + }
1.914 +
1.915 +LOCAL_C void LeaveWithCleanupFailTransactionPushL(CRepository& aRepository)
1.916 + {
1.917 + TInt r = TransactionState(&aRepository);
1.918 + TEST2(r, CRepository::EReadWriteTransaction);
1.919 +
1.920 + aRepository.CleanupFailTransactionPushL();
1.921 +
1.922 + // Purposely leave in a transaction...
1.923 + User::LeaveNoMemory();
1.924 +
1.925 + // this code should never be reached...
1.926 + TEST(EFalse);
1.927 + // ...but if it did we'd have to cleanup the PushL
1.928 + CleanupStack::Pop();
1.929 + }
1.930 +
1.931 +/**
1.932 +@SYMTestCaseID SYSLIB-CENREP-CT-0156
1.933 +@SYMTestCaseDesc Testing CleanupRollbackTransactionPushL and CleanupFailTransactionPushL
1.934 +@SYMTestPriority High
1.935 +@SYMTestActions Start a transaction and use CleanupRollbackTransactionPushL. Within the transaction purposely leave, as this will
1.936 + result in CleanupRollbackTransactionPushL being used. Similar operation required for CleanupFailTransactionPushL
1.937 +@SYMTestExpectedResults The test should not fail with any panics
1.938 +@SYMPREQ PREQ752
1.939 +*/
1.940 +LOCAL_C void CleanupRollBackAndFailTransactionL()
1.941 + {
1.942 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0156 "));
1.943 + TInt r;
1.944 + TUint32 errorId;
1.945 + TReal getValue;
1.946 +
1.947 + CRepository* repository;
1.948 +
1.949 + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));
1.950 +
1.951 + r = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.952 + TEST2(r, KErrNone);
1.953 +
1.954 + repository->CleanupRollbackTransactionPushL();
1.955 +
1.956 + r = repository->Create(KReal2, KReal2_InitialValue);
1.957 + TEST2(r, KErrNone);
1.958 +
1.959 + // Purposely leave in a transaction...
1.960 + TRAP(r, LeaveWithCleanupRollbackTransactionPushL(*repository));
1.961 + TEST2(r, KErrNoMemory);
1.962 +
1.963 + // should cause RollbackTransaction, therefore transaction state should be ENoTransaction...
1.964 +
1.965 + r = TransactionState(repository);
1.966 + TEST2(r, ENoTransaction);
1.967 +
1.968 + // and getting the value KReal2 should result in KErrNotFound
1.969 + r = repository->Get(KReal2, getValue);
1.970 + TEST2(r, KErrNotFound);
1.971 +
1.972 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.973 +
1.974 + r = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.975 + TEST2(r, KErrNone);
1.976 +
1.977 + repository->CleanupFailTransactionPushL();
1.978 +
1.979 + r = repository->Create(KReal2, KReal2_InitialValue);
1.980 + TEST2(r, KErrNone);
1.981 +
1.982 + // Purposely leave in a transaction...
1.983 + TRAP(r, LeaveWithCleanupFailTransactionPushL(*repository));
1.984 + TEST2(r, KErrNoMemory);
1.985 +
1.986 + // should cause FailTransaction, therefore transaction state should be EInFailedReadWriteTransaction...
1.987 + r = TransactionState(repository);
1.988 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.989 +
1.990 + // only after commit will Fail Transaction call roll back...
1.991 + r = repository->CommitTransaction(errorId);
1.992 + TEST2(r, KErrAbort);
1.993 +
1.994 + // so getting the value KReal2 should result in KErrNotFound
1.995 + r = repository->Get(KReal2, getValue);
1.996 + TEST2(r, KErrNotFound);
1.997 +
1.998 + r = TransactionState(repository);
1.999 + TEST2(r, ENoTransaction);
1.1000 +
1.1001 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1002 +
1.1003 + CleanupStack::PopAndDestroy(repository);
1.1004 + }
1.1005 +
1.1006 +/**
1.1007 +@SYMTestCaseID SYSLIB-CENREP-CT-0157
1.1008 +@SYMTestCaseDesc Test Read Transaction Conditions
1.1009 +@SYMTestPriority High
1.1010 +@SYMTestActions Start read transactions and perform read operations
1.1011 +@SYMTestExpectedResults The test should not fail with any panics
1.1012 +@SYMPREQ PREQ752
1.1013 +*/
1.1014 +LOCAL_C void ReadTransactionConditionsL()
1.1015 + {
1.1016 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0157 "));
1.1017 + TInt r;
1.1018 + TUint32 errorId;
1.1019 + TInt intVal;
1.1020 +
1.1021 + CRepository* repository1;
1.1022 + CRepository* repository2;
1.1023 + CRepository* repository3;
1.1024 +
1.1025 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1026 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));
1.1027 + User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository));
1.1028 +
1.1029 + // Begin transaction for repository1
1.1030 + r = repository1->StartTransaction(CRepository::EReadTransaction);
1.1031 + TEST2(r, KErrNone);
1.1032 +
1.1033 + // Should be able to start another read transaction
1.1034 + r = repository2->StartTransaction(CRepository::EReadTransaction);
1.1035 + TEST2(r, KErrNone);
1.1036 +
1.1037 + // Perform some gets using the open transactions and repository
1.1038 + r = repository1->Get(KInt1, intVal);
1.1039 + TEST2(r, KErrNone);
1.1040 + TEST2(intVal, KInt1_InitialValue);
1.1041 +
1.1042 + r = repository2->Get(KInt1, intVal);
1.1043 + TEST2(r, KErrNone);
1.1044 + TEST2(intVal, KInt1_InitialValue);
1.1045 +
1.1046 + r = repository3->Get(KInt1, intVal);
1.1047 + TEST2(r, KErrNone);
1.1048 + TEST2(intVal, KInt1_InitialValue);
1.1049 +
1.1050 + // Get the state of Transactions
1.1051 + r = TransactionState(repository1);
1.1052 + TEST2(r, EReadTransaction);
1.1053 +
1.1054 + r = TransactionState(repository1);
1.1055 + TEST2(r, EReadTransaction);
1.1056 +
1.1057 + r = repository1->CommitTransaction(errorId);
1.1058 + TEST2(r, KErrNone);
1.1059 + // Test for the value of errorId for a successful read transaction: no changes
1.1060 + TEST2(errorId, 0);
1.1061 +
1.1062 + r = repository2->CommitTransaction(errorId);
1.1063 + TEST2(r, KErrNone);
1.1064 + // Test for the value of errorId for a successful read transaction: no changes
1.1065 + TEST2(errorId, 0);
1.1066 +
1.1067 + CleanupStack::PopAndDestroy(repository3);
1.1068 + CleanupStack::PopAndDestroy(repository2);
1.1069 + CleanupStack::PopAndDestroy(repository1);
1.1070 + }
1.1071 +
1.1072 +/**
1.1073 +@SYMTestCaseID SYSLIB-CENREP-CT-0158
1.1074 +@SYMTestCaseDesc Test upgrade read transaction with error conditions
1.1075 +@SYMTestPriority High
1.1076 +@SYMTestActions Start read transactions and try to upgrade one of the read transactions
1.1077 +@SYMTestExpectedResults The test should not fail with any panics
1.1078 +@SYMPREQ PREQ752
1.1079 +*/
1.1080 +LOCAL_C void UpgradeReadTransactionErrorConditionsL()
1.1081 + {
1.1082 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0158 "));
1.1083 + TInt r;
1.1084 + TUint32 errorId;
1.1085 + TInt intVal;
1.1086 +
1.1087 + CRepository* repository1;
1.1088 + CRepository* repository2;
1.1089 + CRepository* repository3;
1.1090 +
1.1091 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1092 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));
1.1093 + User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository));
1.1094 +
1.1095 + // Begin transaction for repository1
1.1096 + r = repository1->StartTransaction(CRepository::EReadTransaction);
1.1097 + TEST2(r, KErrNone);
1.1098 +
1.1099 + // Should be able to start another read transaction
1.1100 + r = repository2->StartTransaction(CRepository::EReadTransaction);
1.1101 + TEST2(r, KErrNone);
1.1102 +
1.1103 + // Perform get using open transaction
1.1104 + r = repository2->Get(KInt1, intVal);
1.1105 + TEST2(r, KErrNone);
1.1106 + TEST2(intVal, KInt1_InitialValue);
1.1107 +
1.1108 + // Perform create which should fail transaction with KErrLocked
1.1109 + r = repository1->Create(KInt2, KInt2_InitialValue);
1.1110 + TEST2(r, KErrLocked);
1.1111 +
1.1112 + // check the value is not there as far as repository 3 is concerned
1.1113 + r = repository3->Get(KInt2, intVal);
1.1114 + TEST2(r, KErrNotFound);
1.1115 +
1.1116 + // Get the state of Transactions
1.1117 + r = TransactionState(repository1);
1.1118 + TEST2(r, EReadTransaction | EFailedBit);
1.1119 +
1.1120 + r = TransactionState(repository2);
1.1121 + TEST2(r, EReadTransaction);
1.1122 +
1.1123 + r = repository2->CommitTransaction(errorId);
1.1124 + TEST2(r, KErrNone);
1.1125 +
1.1126 + r = repository1->CommitTransaction(errorId);
1.1127 + TEST2(r, KErrLocked);
1.1128 + // Check the key responsible for the failed read transaction promote
1.1129 + TEST2(errorId, KInt2);
1.1130 +
1.1131 + CleanupStack::PopAndDestroy(repository3);
1.1132 + CleanupStack::PopAndDestroy(repository2);
1.1133 + CleanupStack::PopAndDestroy(repository1);
1.1134 + }
1.1135 +
1.1136 +/**
1.1137 +@SYMTestCaseID SYSLIB-CENREP-CT-0159
1.1138 +@SYMTestCaseDesc Test read operations with a read write transaction open
1.1139 +@SYMTestPriority High
1.1140 +@SYMTestActions Start a transaction and try to perform some read operations outside of the open transaction
1.1141 +@SYMTestExpectedResults The test should not fail with any panics
1.1142 +@SYMPREQ PREQ752
1.1143 +*/
1.1144 +LOCAL_C void TransactionConditionsForReadL()
1.1145 + {
1.1146 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0159 "));
1.1147 + TInt r;
1.1148 + TUint32 errorId;
1.1149 + RArray<TUint32> foundIds;
1.1150 +
1.1151 + CRepository* repository1;
1.1152 + CRepository* repository2;
1.1153 +
1.1154 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1155 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));
1.1156 +
1.1157 + // Begin transaction for repository1
1.1158 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1159 + TEST2(r, KErrNone);
1.1160 +
1.1161 + r = TransactionState(repository1);
1.1162 + TEST2(r, EReadWriteTransaction);
1.1163 +
1.1164 + // Should be able to get values regardless of transaction1 being open
1.1165 + TInt intVal;
1.1166 + r = repository2->Get(KInt1, intVal);
1.1167 + TEST2(r, KErrNone);
1.1168 + TEST2(intVal, KInt1_InitialValue);
1.1169 +
1.1170 + TReal realVal;
1.1171 + r = repository2->Get(KReal1, realVal);
1.1172 + TEST2(r, KErrNone);
1.1173 + TEST(realVal==KReal1_InitialValue);
1.1174 +
1.1175 + TBuf8<14> buf8Val;
1.1176 + r = repository2->Get(KString8, buf8Val);
1.1177 + TEST2(r, KErrNone);
1.1178 + TEST(buf8Val==KString8_InitialValue);
1.1179 +
1.1180 + TBuf16<14> buf16Val;
1.1181 + r = repository2->Get(KString16, buf16Val);
1.1182 + TEST2(r, KErrNone);
1.1183 + TEST(buf16Val==KString16_InitialValue);
1.1184 +
1.1185 + r = repository2->FindL(0, KUnprotectedSettingsMask, foundIds);
1.1186 + TEST2(r, KErrNone);
1.1187 + TEST(foundIds.Count()==4);
1.1188 +
1.1189 + foundIds.Reset();
1.1190 +
1.1191 + // Find in range for values equal to KInt1_InitialValue
1.1192 + r = repository2->FindEqL(0, KUnprotectedSettingsMask, KInt1_InitialValue, foundIds);
1.1193 + TEST2(r, KErrNone);
1.1194 + TEST(foundIds.Count()==1);
1.1195 +
1.1196 + foundIds.Reset();
1.1197 +
1.1198 + // Find in range for values NOT equal to KInt1_InitialValue
1.1199 + r = repository2->FindNeqL(0, KUnprotectedSettingsMask, KInt1_InitialValue, foundIds);
1.1200 + TEST2(r, KErrNone);
1.1201 + TEST(foundIds.Count()==3);
1.1202 +
1.1203 + foundIds.Reset();
1.1204 +
1.1205 + // Find in range for values equal to KReal1_InitialValue
1.1206 + r = repository2->FindEqL(0, KUnprotectedSettingsMask, KReal1_InitialValue, foundIds);
1.1207 + TEST2(r, KErrNone);
1.1208 + TEST2(foundIds.Count(),1);
1.1209 +
1.1210 + foundIds.Reset();
1.1211 +
1.1212 + // Find in range for values NOT equal to KReal1_InitialValue
1.1213 + r = repository2->FindNeqL(0, KUnprotectedSettingsMask, KReal1_InitialValue, foundIds);
1.1214 + TEST2(r, KErrNone);
1.1215 + TEST2(foundIds.Count(),3);
1.1216 +
1.1217 + // Find in range for values equal to KString8_InitialValue
1.1218 + r = repository2->FindEqL(0, KUnprotectedSettingsMask, KString8_InitialValue, foundIds);
1.1219 + TEST2(r, KErrNone);
1.1220 + TEST(foundIds.Count()==1);
1.1221 +
1.1222 + foundIds.Reset();
1.1223 +
1.1224 + // Find in range for values NOT equal to KString8_InitialValue
1.1225 + r = repository2->FindNeqL(0, KUnprotectedSettingsMask, KString8_InitialValue, foundIds);
1.1226 + TEST2(r, KErrNone);
1.1227 + TEST2(foundIds.Count(),3);
1.1228 +
1.1229 +
1.1230 + // Find in range for values equal to KString16_InitialValue
1.1231 + r = repository2->FindEqL(0, KUnprotectedSettingsMask, KString16_InitialValue, foundIds);
1.1232 + TEST2(r, KErrNone);
1.1233 + TEST2(foundIds.Count(),1);
1.1234 +
1.1235 + foundIds.Reset();
1.1236 +
1.1237 + // Find in range for values NOT equal to KString16_InitialValue
1.1238 + r = repository2->FindNeqL(0, KUnprotectedSettingsMask, KString16_InitialValue, foundIds);
1.1239 + TEST2(r, KErrNone);
1.1240 + TEST2(foundIds.Count(),3);
1.1241 +
1.1242 + foundIds.Reset();
1.1243 +
1.1244 + r = repository1->CommitTransaction(errorId);
1.1245 + TEST2(r, KErrNone);
1.1246 +
1.1247 + CleanupStack::PopAndDestroy(repository2);
1.1248 + CleanupStack::PopAndDestroy(repository1);
1.1249 + }
1.1250 +
1.1251 +/**
1.1252 +@SYMTestCaseID SYSLIB-CENREP-CT-0160
1.1253 +@SYMTestCaseDesc Test Transaction error conditions with get
1.1254 +@SYMTestPriority High
1.1255 +@SYMTestActions Start a transaction and perform some problematic gets. Test to see if it fails transactions or not.
1.1256 +@SYMTestExpectedResults The test should not fail with any panics
1.1257 +@SYMPREQ PREQ752
1.1258 +*/
1.1259 +LOCAL_C void TransactionErrorConditionsForGetL()
1.1260 + {
1.1261 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0160 "));
1.1262 + TInt r;
1.1263 + TUint32 errorId;
1.1264 +
1.1265 + CRepository* repository1;
1.1266 +
1.1267 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1268 +
1.1269 + // Begin transaction for repository1
1.1270 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1271 + TEST2(r, KErrNone);
1.1272 +
1.1273 + // Should NOT fail transaction
1.1274 + TInt intVal;
1.1275 + r = repository1->Get(KInt2, intVal);
1.1276 + TEST2(r, KErrNotFound);
1.1277 +
1.1278 + r = TransactionState(repository1);
1.1279 + TEST2(r, EReadWriteTransaction);
1.1280 +
1.1281 + // Should NOT fail transaction
1.1282 + TReal realVal;
1.1283 + r = repository1->Get(KInt1, realVal);
1.1284 + TEST2(r, KErrArgument);
1.1285 +
1.1286 + r = TransactionState(repository1);
1.1287 + TEST2(r, EReadWriteTransaction);
1.1288 +
1.1289 + // Should NOT fail transaction
1.1290 + r = repository1->Get(KReal2, realVal);
1.1291 + TEST2(r, KErrNotFound);
1.1292 +
1.1293 + r = TransactionState(repository1);
1.1294 + TEST2(r, EReadWriteTransaction);
1.1295 +
1.1296 + // Should NOT fail transaction
1.1297 + r = repository1->Get(KReal1, intVal);
1.1298 + TEST2(r, KErrArgument);
1.1299 +
1.1300 + r = TransactionState(repository1);
1.1301 + TEST2(r, EReadWriteTransaction);
1.1302 +
1.1303 + // Should NOT fail transaction
1.1304 + TBuf8<14> buf8Val;
1.1305 + r = repository1->Get(KNewString8, buf8Val);
1.1306 + TEST2(r, KErrNotFound);
1.1307 +
1.1308 + r = TransactionState(repository1);
1.1309 + TEST2(r, EReadWriteTransaction);
1.1310 +
1.1311 + // Should NOT fail transaction
1.1312 + r = repository1->Get(KString8, intVal);
1.1313 + TEST2(r, KErrArgument);
1.1314 +
1.1315 + r = TransactionState(repository1);
1.1316 + TEST2(r, EReadWriteTransaction);
1.1317 +
1.1318 + // Should NOT fail transaction
1.1319 + TBuf8<2> smallBuf8Val;
1.1320 + r = repository1->Get(KString8, smallBuf8Val);
1.1321 + TEST2(r, KErrOverflow);
1.1322 + TEST(smallBuf8Val==KString8_Small_Value);
1.1323 +
1.1324 + r = TransactionState(repository1);
1.1325 + TEST2(r, EReadWriteTransaction);
1.1326 +
1.1327 + // Should NOT fail transaction
1.1328 + TBuf16<14> buf16Val;
1.1329 + r = repository1->Get(KNewString16, buf16Val);
1.1330 + TEST2(r, KErrNotFound);
1.1331 +
1.1332 + r = TransactionState(repository1);
1.1333 + TEST2(r, EReadWriteTransaction);
1.1334 +
1.1335 + // Should NOT fail transaction
1.1336 + r = repository1->Get(KString16, intVal);
1.1337 + TEST2(r, KErrArgument);
1.1338 +
1.1339 + r = TransactionState(repository1);
1.1340 + TEST2(r, EReadWriteTransaction);
1.1341 +
1.1342 + // Should NOT fail transaction
1.1343 + TBuf16<2> smallBuf16Val;
1.1344 + r = repository1->Get(KString16, smallBuf16Val);
1.1345 + TEST2(r, KErrOverflow);
1.1346 + TEST(smallBuf16Val==KString16_Small_Value);
1.1347 +
1.1348 + r = TransactionState(repository1);
1.1349 + TEST2(r, EReadWriteTransaction);
1.1350 +
1.1351 + r = repository1->CommitTransaction(errorId);
1.1352 + TEST2(r, KErrNone);
1.1353 +
1.1354 + r = TransactionState(repository1);
1.1355 + TEST2(r, ENoTransaction);
1.1356 +
1.1357 + CleanupStack::PopAndDestroy(repository1);
1.1358 + }
1.1359 +
1.1360 +/**
1.1361 +@SYMTestCaseID SYSLIB-CENREP-CT-0161
1.1362 +@SYMTestCaseDesc Test Transaction error conditions with find
1.1363 +@SYMTestPriority High
1.1364 +@SYMTestActions Start a transaction and perform some problematic find operations. Test to see if it fails transactions or not.
1.1365 +@SYMTestExpectedResults The test should not fail with any panics
1.1366 +@SYMPREQ PREQ752
1.1367 +*/
1.1368 +LOCAL_C void TransactionErrorConditionsForFindL()
1.1369 + {
1.1370 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0161 "));
1.1371 + TInt r;
1.1372 + TUint32 errorId;
1.1373 + RArray<TUint32> foundIds;
1.1374 +
1.1375 + CRepository* repository1;
1.1376 +
1.1377 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1378 +
1.1379 + // Begin transaction for repository1
1.1380 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1381 + TEST2(r, KErrNone);
1.1382 +
1.1383 + repository1->CleanupRollbackTransactionPushL();
1.1384 +
1.1385 + // Should NOT fail transaction
1.1386 + r = repository1->FindL(100, 110, foundIds);
1.1387 + TEST2(r, KErrNotFound);
1.1388 +
1.1389 + foundIds.Reset();
1.1390 +
1.1391 + r = TransactionState(repository1);
1.1392 + TEST2(r, EReadWriteTransaction);
1.1393 +
1.1394 + r = repository1->CommitTransaction(errorId);
1.1395 + TEST2(r, KErrNone);
1.1396 +
1.1397 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1398 +
1.1399 + r = TransactionState(repository1);
1.1400 + TEST2(r, ENoTransaction);
1.1401 +
1.1402 + CleanupStack::PopAndDestroy(repository1);
1.1403 + }
1.1404 +
1.1405 +/**
1.1406 +@SYMTestCaseID SYSLIB-CENREP-CT-0162
1.1407 +@SYMTestCaseDesc Test Transaction error conditions with findeq
1.1408 +@SYMTestPriority High
1.1409 +@SYMTestActions Start a transaction and perform some problematic findeq operations. Test to see if it fails transactions or not.
1.1410 +@SYMTestExpectedResults The test should not fail with any panics
1.1411 +@SYMPREQ PREQ752
1.1412 +*/
1.1413 +LOCAL_C void TransactionErrorConditionsForFindEqL()
1.1414 + {
1.1415 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0162 "));
1.1416 + TInt r;
1.1417 + TUint32 errorId;
1.1418 + RArray<TUint32> foundIds;
1.1419 +
1.1420 + CRepository* repository1;
1.1421 +
1.1422 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1423 +
1.1424 + // Begin transaction for repository1
1.1425 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1426 + TEST2(r, KErrNone);
1.1427 +
1.1428 + repository1->CleanupRollbackTransactionPushL();
1.1429 +
1.1430 + // Should NOT fail transaction
1.1431 + r = repository1->FindEqL(0, KUnprotectedSettingsMask, KInt2_InitialValue, foundIds);
1.1432 + TEST2(r, KErrNotFound);
1.1433 +
1.1434 + foundIds.Reset();
1.1435 +
1.1436 + r = TransactionState(repository1);
1.1437 + TEST2(r, EReadWriteTransaction);
1.1438 +
1.1439 + r = repository1->CommitTransaction(errorId);
1.1440 + TEST2(r, KErrNone);
1.1441 +
1.1442 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1443 +
1.1444 + r = TransactionState(repository1);
1.1445 + TEST2(r, ENoTransaction);
1.1446 +
1.1447 + // Begin transaction for repository1
1.1448 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1449 + TEST2(r, KErrNone);
1.1450 +
1.1451 + repository1->CleanupRollbackTransactionPushL();
1.1452 +
1.1453 + // Should NOT fail transaction
1.1454 + r = repository1->FindEqL(0, KUnprotectedSettingsMask, KReal2_InitialValue, foundIds);
1.1455 + TEST2(r, KErrNotFound);
1.1456 +
1.1457 + foundIds.Reset();
1.1458 +
1.1459 + r = TransactionState(repository1);
1.1460 + TEST2(r, EReadWriteTransaction);
1.1461 +
1.1462 + r = repository1->CommitTransaction(errorId);
1.1463 + TEST2(r, KErrNone);
1.1464 +
1.1465 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1466 +
1.1467 + r = TransactionState(repository1);
1.1468 + TEST2(r, ENoTransaction);
1.1469 +
1.1470 + // Begin transaction for repository1
1.1471 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1472 + TEST2(r, KErrNone);
1.1473 +
1.1474 + repository1->CleanupRollbackTransactionPushL();
1.1475 +
1.1476 + // Should NOT fail transaction
1.1477 + r = repository1->FindEqL(0, KUnprotectedSettingsMask, KString8_InitialValue2, foundIds);
1.1478 + TEST2(r, KErrNotFound);
1.1479 +
1.1480 + foundIds.Reset();
1.1481 +
1.1482 + r = TransactionState(repository1);
1.1483 + TEST2(r, EReadWriteTransaction);
1.1484 +
1.1485 + r = repository1->CommitTransaction(errorId);
1.1486 + TEST2(r, KErrNone);
1.1487 +
1.1488 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1489 +
1.1490 + r = TransactionState(repository1);
1.1491 + TEST2(r, ENoTransaction);
1.1492 +
1.1493 + // Begin transaction for repository1
1.1494 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1495 + TEST2(r, KErrNone);
1.1496 +
1.1497 + repository1->CleanupRollbackTransactionPushL();
1.1498 +
1.1499 + // Should NOT fail transaction
1.1500 + r = repository1->FindEqL(0, KUnprotectedSettingsMask, KString16_InitialValue2, foundIds);
1.1501 + TEST2(r, KErrNotFound);
1.1502 +
1.1503 + foundIds.Reset();
1.1504 +
1.1505 + r = TransactionState(repository1);
1.1506 + TEST2(r, EReadWriteTransaction);
1.1507 +
1.1508 + r = repository1->CommitTransaction(errorId);
1.1509 + TEST2(r, KErrNone);
1.1510 +
1.1511 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1512 +
1.1513 + r = TransactionState(repository1);
1.1514 + TEST2(r, ENoTransaction);
1.1515 +
1.1516 + CleanupStack::PopAndDestroy(repository1);
1.1517 + }
1.1518 +
1.1519 +/**
1.1520 +@SYMTestCaseID SYSLIB-CENREP-CT-0163
1.1521 +@SYMTestCaseDesc Test Transaction error conditions with findneq
1.1522 +@SYMTestPriority High
1.1523 +@SYMTestActions Start a transaction and perform some problematic findneq operations. Test to see if it fails transactions or not.
1.1524 +@SYMTestExpectedResults The test should not fail with any panics
1.1525 +@SYMPREQ PREQ752
1.1526 +*/
1.1527 +LOCAL_C void TransactionErrorConditionsForFindNeqL()
1.1528 + {
1.1529 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0163 "));
1.1530 + TInt r;
1.1531 + TUint32 errorId;
1.1532 + RArray<TUint32> foundIds;
1.1533 +
1.1534 + CRepository* repository1;
1.1535 +
1.1536 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1537 +
1.1538 + // Begin transaction for repository1
1.1539 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1540 + TEST2(r, KErrNone);
1.1541 +
1.1542 + repository1->CleanupRollbackTransactionPushL();
1.1543 +
1.1544 + // Should NOT fail transaction
1.1545 + r = repository1->FindNeqL(100, 110, KInt1_InitialValue, foundIds);
1.1546 + TEST2(r, KErrNotFound);
1.1547 +
1.1548 + foundIds.Reset();
1.1549 +
1.1550 + r = TransactionState(repository1);
1.1551 + TEST2(r, EReadWriteTransaction);
1.1552 +
1.1553 + r = repository1->CommitTransaction(errorId);
1.1554 + TEST2(r, KErrNone);
1.1555 +
1.1556 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1557 +
1.1558 + r = TransactionState(repository1);
1.1559 + TEST2(r, ENoTransaction);
1.1560 +
1.1561 + // Begin transaction for repository1
1.1562 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1563 + TEST2(r, KErrNone);
1.1564 +
1.1565 + repository1->CleanupRollbackTransactionPushL();
1.1566 +
1.1567 + // Should NOT fail transaction
1.1568 + r = repository1->FindNeqL(100, 110, KReal1_InitialValue, foundIds);
1.1569 + TEST2(r, KErrNotFound);
1.1570 +
1.1571 + foundIds.Reset();
1.1572 +
1.1573 + r = TransactionState(repository1);
1.1574 + TEST2(r, EReadWriteTransaction);
1.1575 +
1.1576 + r = repository1->CommitTransaction(errorId);
1.1577 + TEST2(r, KErrNone);
1.1578 +
1.1579 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1580 +
1.1581 + r = TransactionState(repository1);
1.1582 + TEST2(r, ENoTransaction);
1.1583 +
1.1584 + // Begin transaction for repository1
1.1585 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1586 + TEST2(r, KErrNone);
1.1587 +
1.1588 + repository1->CleanupRollbackTransactionPushL();
1.1589 +
1.1590 + // Should NOT fail transaction
1.1591 + r = repository1->FindNeqL(100, 110, KString8_InitialValue, foundIds);
1.1592 + TEST2(r, KErrNotFound);
1.1593 +
1.1594 + foundIds.Reset();
1.1595 +
1.1596 + r = TransactionState(repository1);
1.1597 + TEST2(r, EReadWriteTransaction);
1.1598 +
1.1599 + r = repository1->CommitTransaction(errorId);
1.1600 + TEST2(r, KErrNone);
1.1601 +
1.1602 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1603 +
1.1604 + r = TransactionState(repository1);
1.1605 + TEST2(r, ENoTransaction);
1.1606 +
1.1607 + // Begin transaction for repository1
1.1608 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1609 + TEST2(r, KErrNone);
1.1610 +
1.1611 + repository1->CleanupRollbackTransactionPushL();
1.1612 +
1.1613 + // Should NOT fail transaction
1.1614 + r = repository1->FindNeqL(100, 110, KString16_InitialValue, foundIds);
1.1615 + TEST2(r, KErrNotFound);
1.1616 +
1.1617 + foundIds.Reset();
1.1618 +
1.1619 + r = TransactionState(repository1);
1.1620 + TEST2(r, EReadWriteTransaction);
1.1621 +
1.1622 + r = repository1->CommitTransaction(errorId);
1.1623 + TEST2(r, KErrNone);
1.1624 +
1.1625 + CleanupStack::Pop(); // CleanupRollbackTransaction
1.1626 +
1.1627 + r = TransactionState(repository1);
1.1628 + TEST2(r, ENoTransaction);
1.1629 +
1.1630 + CleanupStack::PopAndDestroy(repository1);
1.1631 + }
1.1632 +
1.1633 +/**
1.1634 +@SYMTestCaseID SYSLIB-CENREP-CT-0164
1.1635 +@SYMTestCaseDesc Test Transaction error conditions with create
1.1636 +@SYMTestPriority High
1.1637 +@SYMTestActions Start a transaction and perform some problematic create operations. Test to see if it fails transactions or not.
1.1638 +@SYMTestExpectedResults The test should not fail with any panics
1.1639 +@SYMPREQ PREQ752
1.1640 +*/
1.1641 +LOCAL_C void TransactionErrorConditionsForCreateL()
1.1642 + {
1.1643 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0164 "));
1.1644 + TInt r;
1.1645 + TUint32 errorId;
1.1646 +
1.1647 + CRepository* repository1;
1.1648 +
1.1649 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1650 +
1.1651 + // Begin transaction for repository1
1.1652 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1653 + TEST2(r, KErrNone);
1.1654 +
1.1655 + // Should fail the transaction
1.1656 + r = repository1->Create(KInt1, KInt1_InitialValue);
1.1657 + TEST2(r, KErrAlreadyExists);
1.1658 +
1.1659 + r = TransactionState(repository1);
1.1660 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.1661 +
1.1662 + r = repository1->CommitTransaction(errorId);
1.1663 + TEST2(r, KErrAlreadyExists);
1.1664 + TEST2(errorId, KInt1);
1.1665 +
1.1666 + r = TransactionState(repository1);
1.1667 + TEST2(r, ENoTransaction);
1.1668 +
1.1669 + // Begin transaction for repository1
1.1670 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1671 + TEST2(r, KErrNone);
1.1672 +
1.1673 + // Should fail the transaction
1.1674 + r = repository1->Create(KReal1, KReal1_InitialValue);
1.1675 + TEST2(r, KErrAlreadyExists);
1.1676 +
1.1677 + r = TransactionState(repository1);
1.1678 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.1679 +
1.1680 + r = repository1->CommitTransaction(errorId);
1.1681 + TEST2(r, KErrAlreadyExists);
1.1682 + TEST2(errorId, KReal1);
1.1683 +
1.1684 + r = TransactionState(repository1);
1.1685 + TEST2(r, ENoTransaction);
1.1686 +
1.1687 + // Begin transaction for repository1
1.1688 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1689 + TEST2(r, KErrNone);
1.1690 +
1.1691 + // Should fail the transaction
1.1692 + r = repository1->Create(KString8, KString8_InitialValue);
1.1693 + TEST2(r, KErrAlreadyExists);
1.1694 +
1.1695 + r = TransactionState(repository1);
1.1696 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.1697 +
1.1698 + r = repository1->CommitTransaction(errorId);
1.1699 + TEST2(r, KErrAlreadyExists);
1.1700 + TEST2(errorId, KString8);
1.1701 +
1.1702 + r = TransactionState(repository1);
1.1703 + TEST2(r, ENoTransaction);
1.1704 +
1.1705 + // Begin transaction for repository1
1.1706 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1707 + TEST2(r, KErrNone);
1.1708 +
1.1709 + // Should fail the transaction
1.1710 + r = repository1->Create(KString16, KString16_InitialValue);
1.1711 + TEST2(r, KErrAlreadyExists);
1.1712 +
1.1713 + r = TransactionState(repository1);
1.1714 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.1715 +
1.1716 + r = repository1->CommitTransaction(errorId);
1.1717 + TEST2(r, KErrAlreadyExists);
1.1718 + TEST2(errorId, KString16);
1.1719 +
1.1720 + r = TransactionState(repository1);
1.1721 + TEST2(r, ENoTransaction);
1.1722 +
1.1723 + CleanupStack::PopAndDestroy(repository1);
1.1724 + }
1.1725 +
1.1726 +/**
1.1727 +@SYMTestCaseID SYSLIB-CENREP-CT-0165
1.1728 +@SYMTestCaseDesc Test Transaction error conditions with delete
1.1729 +@SYMTestPriority High
1.1730 +@SYMTestActions Start a transaction and perform some problematic delete operations. Test to see if it fails transactions or not.
1.1731 +@SYMTestExpectedResults The test should not fail with any panics
1.1732 +@SYMPREQ PREQ752
1.1733 +*/
1.1734 +LOCAL_C void TransactionErrorConditionsForDeleteL()
1.1735 + {
1.1736 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0165 "));
1.1737 + TInt r;
1.1738 + TUint32 errorId;
1.1739 +
1.1740 + CRepository* repository1;
1.1741 +
1.1742 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1743 +
1.1744 + // Begin transaction for repository1
1.1745 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1746 + TEST2(r, KErrNone);
1.1747 +
1.1748 + // Delete KInt2 which does not exist
1.1749 + r = repository1->Delete(KInt2);
1.1750 + TEST2(r, KErrNotFound);
1.1751 +
1.1752 + r = TransactionState(repository1);
1.1753 + TEST2(r, EReadWriteTransaction);
1.1754 +
1.1755 + r = repository1->CommitTransaction(errorId);
1.1756 + TEST2(r, KErrNone);
1.1757 +
1.1758 + r = TransactionState(repository1);
1.1759 + TEST2(r, ENoTransaction);
1.1760 +
1.1761 + CleanupStack::PopAndDestroy(repository1);
1.1762 + }
1.1763 +
1.1764 +/**
1.1765 +@SYMTestCaseID SYSLIB-CENREP-CT-0166
1.1766 +@SYMTestCaseDesc Test Transaction error conditions with set
1.1767 +@SYMTestPriority High
1.1768 +@SYMTestActions Start a transaction and perform some problematic set operations. Test to see if it fails transactions or not.
1.1769 +@SYMTestExpectedResults The test should not fail with any panics
1.1770 +@SYMPREQ PREQ752
1.1771 +*/
1.1772 +LOCAL_C void TransactionErrorConditionsForSetL()
1.1773 + {
1.1774 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0166 "));
1.1775 + TInt r;
1.1776 + TUint32 errorId;
1.1777 + TInt i;
1.1778 +
1.1779 + CRepository* repository1;
1.1780 +
1.1781 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1782 +
1.1783 + // Begin transaction for repository1
1.1784 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1785 + TEST2(r, KErrNone);
1.1786 +
1.1787 + r = repository1->Get(KInt2, i);
1.1788 + TEST2(r, KErrNotFound);
1.1789 +
1.1790 + // Set KInt2 which does not exist
1.1791 + r = repository1->Set(KInt2, KInt2_InitialValue);
1.1792 + TEST2(r, KErrNone);
1.1793 +
1.1794 + r = repository1->Get(KInt2, i);
1.1795 + TEST2(r, KErrNone);
1.1796 + TEST2(i, KInt2_InitialValue);
1.1797 +
1.1798 + // Set KInt2 to a value of real type
1.1799 + r = repository1->Set(KInt2, KReal2_InitialValue);
1.1800 + TEST2(r, KErrArgument);
1.1801 +
1.1802 + r = TransactionState(repository1);
1.1803 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.1804 +
1.1805 + r = repository1->CommitTransaction(errorId);
1.1806 + TEST2(r, KErrArgument);
1.1807 + TEST2(errorId, KInt2);
1.1808 +
1.1809 + r = TransactionState(repository1);
1.1810 + TEST2(r, ENoTransaction);
1.1811 +
1.1812 + // Begin transaction for repository1
1.1813 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1814 + TEST2(r, KErrNone);
1.1815 +
1.1816 + r = repository1->Set(KInt2, KInt2_InitialValue + 1);
1.1817 + TEST2(r, KErrNone);
1.1818 +
1.1819 + // Set KInt2 to a value of string8 type
1.1820 + r = repository1->Set(KInt2, KString8_InitialValue);
1.1821 + TEST2(r, KErrArgument);
1.1822 +
1.1823 + r = TransactionState(repository1);
1.1824 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.1825 +
1.1826 + r = repository1->CommitTransaction(errorId);
1.1827 + TEST2(r, KErrArgument);
1.1828 + TEST2(errorId, KInt2);
1.1829 +
1.1830 + r = TransactionState(repository1);
1.1831 + TEST2(r, ENoTransaction);
1.1832 +
1.1833 + // Begin transaction for repository1
1.1834 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1835 + TEST2(r, KErrNone);
1.1836 +
1.1837 + r = repository1->Set(KInt2, KInt2_InitialValue + 1);
1.1838 + TEST2(r, KErrNone);
1.1839 +
1.1840 + // Set KInt2 to a value of string16 type
1.1841 + r = repository1->Set(KInt2, KString16_InitialValue);
1.1842 + TEST2(r, KErrArgument);
1.1843 +
1.1844 + r = TransactionState(repository1);
1.1845 + TEST2(r, EReadWriteTransaction | EFailedBit);
1.1846 +
1.1847 + r = repository1->CommitTransaction(errorId);
1.1848 + TEST2(r, KErrArgument);
1.1849 + TEST2(errorId, KInt2);
1.1850 +
1.1851 + r = TransactionState(repository1);
1.1852 + TEST2(r, ENoTransaction);
1.1853 +
1.1854 + CleanupStack::PopAndDestroy(repository1);
1.1855 + }
1.1856 +
1.1857 +/**
1.1858 +@SYMTestCaseID SYSLIB-CENREP-CT-0167
1.1859 +@SYMTestCaseDesc Test Transaction error conditions with move
1.1860 +@SYMTestPriority High
1.1861 +@SYMTestActions Start a transaction and perform some problematic move operations. Test to see if it fails transactions or not.
1.1862 +@SYMTestExpectedResults The test should not fail with any panics
1.1863 +@SYMPREQ PREQ752
1.1864 +*/
1.1865 +LOCAL_C void TransactionErrorConditionsForMoveL()
1.1866 + {
1.1867 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0167 "));
1.1868 + TInt r;
1.1869 + TUint32 errorId;
1.1870 +
1.1871 + CRepository* repository1;
1.1872 +
1.1873 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1874 +
1.1875 + // Begin transaction for repository1
1.1876 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1877 + TEST2(r, KErrNone);
1.1878 +
1.1879 + // Move a set of keys which does not exist
1.1880 + r = repository1->Move(KMoveSourceDoesntExist, KMoveTarget, KMoveMask, errorId) ;
1.1881 + TEST2(r, KErrNotFound);
1.1882 +
1.1883 + r = TransactionState(repository1);
1.1884 + TEST2(r, EReadWriteTransaction);
1.1885 +
1.1886 + r = repository1->Move(KInt1, KInt1, KMoveMask, errorId) ;
1.1887 + TEST2(r, KErrNone);
1.1888 +
1.1889 + r = TransactionState(repository1);
1.1890 + TEST2(r, EReadWriteTransaction);
1.1891 +
1.1892 + r = repository1->CommitTransaction(errorId);
1.1893 + TEST2(r, KErrNone);
1.1894 +
1.1895 + r = TransactionState(repository1);
1.1896 + TEST2(r, ENoTransaction);
1.1897 +
1.1898 + CleanupStack::PopAndDestroy(repository1);
1.1899 + }
1.1900 +
1.1901 +/**
1.1902 +@SYMTestCaseID SYSLIB-CENREP-CT-0168
1.1903 +@SYMTestCaseDesc Test move operation with more comprehensive test cases
1.1904 +@SYMTestPriority High
1.1905 +@SYMTestActions Start a transaction and try to perform some problematic move operations. Check result of operation.
1.1906 +@SYMTestExpectedResults The test should not fail with any panics
1.1907 +@SYMPREQ PREQ752
1.1908 +*/
1.1909 +LOCAL_C void TransactionConditionsForMoveL()
1.1910 + {
1.1911 + // More comprehensive test cases for MOVE
1.1912 +
1.1913 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0168 "));
1.1914 + TInt r;
1.1915 + TUint32 errorId;
1.1916 + TBuf8<16> buf8Val;
1.1917 +
1.1918 + CRepository* repository1;
1.1919 +
1.1920 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1921 +
1.1922 + // Begin transaction for repository1
1.1923 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.1924 + TEST2(r, KErrNone);
1.1925 +
1.1926 + // Move a set of keys which does not exist
1.1927 + r = repository1->Move(KNewString8, KMoveTarget, KMoveMask, errorId);
1.1928 + TEST2(r, KErrNotFound);
1.1929 +
1.1930 + r = TransactionState(repository1);
1.1931 + TEST2(r, EReadWriteTransaction);
1.1932 +
1.1933 + r = repository1->Create(KNewString8, KString8_InitialValue2);
1.1934 + TEST2(r, KErrNone);
1.1935 +
1.1936 + //Move KNewString8 to KMoveTarget
1.1937 + r = repository1->Move(KNewString8, KMoveTarget, KMoveMask, errorId);
1.1938 + TEST2(r, KErrNone);
1.1939 +
1.1940 + r = repository1->Get(KNewString8, buf8Val);
1.1941 + TEST2(r, KErrNotFound);
1.1942 +
1.1943 + r = TransactionState(repository1);
1.1944 + TEST2(r, EReadWriteTransaction);
1.1945 +
1.1946 + // Move keys back again
1.1947 + r = repository1->Move(KMoveTarget, KNewString8, KMoveMask, errorId);
1.1948 + TEST2(r, KErrNone);
1.1949 +
1.1950 + r = repository1->Get(KNewString8, buf8Val);
1.1951 + TEST2(r, KErrNone);
1.1952 + TEST(buf8Val==KString8_InitialValue2);
1.1953 +
1.1954 + r = repository1->CommitTransaction(errorId);
1.1955 + TEST2(r, KErrNone);
1.1956 +
1.1957 + // Reset the test by deleting KNewString8...
1.1958 + r = repository1->Delete(KNewString8);
1.1959 + TEST2(r, KErrNone);
1.1960 +
1.1961 + CleanupStack::PopAndDestroy(repository1);
1.1962 + }
1.1963 +
1.1964 +/**
1.1965 +@SYMTestCaseID SYSLIB-CENREP-CT-0169
1.1966 +@SYMTestCaseDesc Test concurrent read and write transactions
1.1967 +@SYMTestPriority High
1.1968 +@SYMTestActions Start a concurrent read write transaction and perform some operations. Check the state of transaction
1.1969 +@SYMTestExpectedResults The test should not fail with any panics
1.1970 +@SYMPREQ PREQ752
1.1971 +*/
1.1972 +LOCAL_C void ConcurrentReadWriteTransactionStatesL()
1.1973 + {
1.1974 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0169 "));
1.1975 + TInt r;
1.1976 + TUint32 errorId;
1.1977 + TReal getValue;
1.1978 +
1.1979 + CRepository* repository1;
1.1980 +
1.1981 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.1982 +
1.1983 + // Begin transaction for repository1
1.1984 + r = repository1->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.1985 + TEST2(r, KErrNone);
1.1986 +
1.1987 + r = TransactionState(repository1);
1.1988 + TEST2(r, EConcurrentReadWriteTransaction);
1.1989 +
1.1990 + r = repository1->Create(KReal2, KReal2_InitialValue);
1.1991 + TEST2(r, KErrNone);
1.1992 +
1.1993 + r = repository1->Get(KReal2, getValue);
1.1994 + TEST2(r, KErrNone);
1.1995 +
1.1996 + // Fail transaction should roll back transaction i.e. Create KReal2 should not work.
1.1997 + repository1->FailTransaction();
1.1998 +
1.1999 + r = TransactionState(repository1);
1.2000 + TEST2(r, EConcurrentReadWriteTransaction | EFailedBit);
1.2001 +
1.2002 + // Commit transaction
1.2003 + r = repository1->CommitTransaction(errorId);
1.2004 + TEST2(r, KErrAbort);
1.2005 +
1.2006 + // Try to get a value which should not exist as transaction failed
1.2007 + r = repository1->Get(KReal2, getValue);
1.2008 + TEST2(r, KErrNotFound);
1.2009 +
1.2010 + r = TransactionState(repository1);
1.2011 + TEST2(r, ENoTransaction);
1.2012 +
1.2013 + CleanupStack::PopAndDestroy(repository1);
1.2014 + }
1.2015 +
1.2016 +/**
1.2017 +@SYMTestCaseID SYSLIB-CENREP-CT-0170
1.2018 +@SYMTestCaseDesc Test concurrent read and write transaction with read operations
1.2019 +@SYMTestPriority High
1.2020 +@SYMTestActions Start a concurrent read write and a read transaction and perform some read operations. Check the state of transaction
1.2021 +@SYMTestExpectedResults The test should not fail with any panics
1.2022 +@SYMPREQ PREQ752
1.2023 +*/
1.2024 +LOCAL_C void ConcurrentReadWriteTransactionWithReadOperationsL()
1.2025 + {
1.2026 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0170 "));
1.2027 + TInt r;
1.2028 + TUint32 errorId;
1.2029 + TReal getValue;
1.2030 +
1.2031 + CRepository* repository1;
1.2032 + CRepository* repository2;
1.2033 + CRepository* repository3;
1.2034 +
1.2035 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.2036 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));
1.2037 + User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository));
1.2038 +
1.2039 + // Begin concurrent read write transaction for repository1
1.2040 + r = repository1->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.2041 + TEST2(r, KErrNone);
1.2042 +
1.2043 + // Begin read transaction for repository2
1.2044 + r = repository2->StartTransaction(CRepository::EReadTransaction);
1.2045 +
1.2046 + r = TransactionState(repository1);
1.2047 + TEST2(r, EConcurrentReadWriteTransaction);
1.2048 +
1.2049 + r = TransactionState(repository2);
1.2050 + TEST2(r, EReadTransaction);
1.2051 +
1.2052 + // Create value in with a concurrent read write transaction
1.2053 + r = repository1->Create(KReal2, KReal2_InitialValue);
1.2054 + TEST2(r, KErrNone);
1.2055 +
1.2056 + // Get value set using another transaction
1.2057 + r = repository2->Get(KReal1, getValue);
1.2058 + TEST2(r, KErrNone);
1.2059 + TEST(getValue == KReal1_InitialValue);
1.2060 +
1.2061 + // Get value set outside of a transaction using repository3
1.2062 + r = repository3->Get(KReal1, getValue);
1.2063 + TEST2(r, KErrNone);
1.2064 + TEST(getValue == KReal1_InitialValue);
1.2065 +
1.2066 + // Get value set within another transaction but not commited, within a transaction
1.2067 + r = repository2->Get(KReal2, getValue);
1.2068 + TEST2(r, KErrNotFound);
1.2069 +
1.2070 + // Get value set within another transaction but not commited, outside of a transaction
1.2071 + r = repository3->Get(KReal2, getValue);
1.2072 + TEST2(r, KErrNotFound);
1.2073 +
1.2074 + // Commit repository2
1.2075 + r = repository2->CommitTransaction(errorId);
1.2076 + TEST2(r, KErrNone);
1.2077 +
1.2078 + // Commit repository1
1.2079 + r = repository1->CommitTransaction(errorId);
1.2080 + TEST2(r, KErrNone);
1.2081 +
1.2082 + CleanupStack::PopAndDestroy(repository3);
1.2083 + CleanupStack::PopAndDestroy(repository2);
1.2084 + CleanupStack::PopAndDestroy(repository1);
1.2085 +
1.2086 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.2087 +
1.2088 + // Check that value was persisted
1.2089 + r = repository1->Get(KReal2, getValue);
1.2090 + TEST2(r, KErrNone);
1.2091 + TEST(getValue == KReal2_InitialValue);
1.2092 +
1.2093 + // Delete KReal2 to reset available test case variables
1.2094 + r = repository1->Delete(KReal2);
1.2095 + TEST2(r, KErrNone);
1.2096 +
1.2097 + CleanupStack::PopAndDestroy(repository1);
1.2098 + }
1.2099 +
1.2100 +LOCAL_C void Defect058796()
1.2101 + {
1.2102 + TInt r;
1.2103 + TUint32 errorId;
1.2104 +
1.2105 + TBuf8<2> buf8ValSmall;
1.2106 + TBuf16<2> buf16ValSmall;
1.2107 +
1.2108 + TBuf8<16> buf8Val;
1.2109 + TBuf16<16> buf16Val;
1.2110 +
1.2111 + TInt length;
1.2112 +
1.2113 + CRepository* repository1;
1.2114 +
1.2115 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.2116 +
1.2117 + // Start a read write transaction
1.2118 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.2119 + TEST2(r, KErrNone);
1.2120 +
1.2121 + // Try to get a string value using a TBuf8 with length which is too small
1.2122 + r = repository1->Get(KString8, buf8ValSmall, length);
1.2123 + TEST2(r, KErrOverflow);
1.2124 + TEST(buf8ValSmall == KString8_Small_Value);
1.2125 + TEST2(length, 13);
1.2126 +
1.2127 + // Try to get a string value using a TBuf16 with length which is too small
1.2128 + r = repository1->Get(KString16, buf16ValSmall, length);
1.2129 + TEST2(r, KErrOverflow);
1.2130 + TEST(buf16ValSmall == KString16_Small_Value);
1.2131 + TEST2(length, 13);
1.2132 +
1.2133 + // Set KNewString16 and KNewString8
1.2134 + r = repository1->Create(KNewString16, KString16_InitialValue2);
1.2135 + TEST2(r, KErrNone);
1.2136 + r = repository1->Create(KNewString8, KString8_InitialValue2);
1.2137 + TEST2(r, KErrNone);
1.2138 +
1.2139 + // Try to get KNewString16 with a TBuf16 which is a suitable size
1.2140 + r = repository1->Get(KNewString16, buf16Val, length);
1.2141 + TEST2(r, KErrNone);
1.2142 + TEST(buf16Val == KString16_InitialValue2);
1.2143 + TEST2(length, 16);
1.2144 +
1.2145 + // Try to get KNewString8 with a TBuf8 which is a suitable size
1.2146 + r = repository1->Get(KNewString8, buf8Val, length);
1.2147 + TEST2(r, KErrNone);
1.2148 + TEST(buf8Val == KString8_InitialValue2);
1.2149 + TEST2(length, 16);
1.2150 +
1.2151 + // Commit the transaction
1.2152 + r = repository1->CommitTransaction(errorId);
1.2153 + TEST2(r, KErrNone);
1.2154 +
1.2155 + // Delete KNewString8 to reset available test case variables
1.2156 + r = repository1->Delete(KNewString8);
1.2157 + TEST2(r, KErrNone);
1.2158 +
1.2159 + // Delete KNewString16 to reset available test case variables
1.2160 + r = repository1->Delete(KNewString16);
1.2161 + TEST2(r, KErrNone);
1.2162 +
1.2163 + CleanupStack::PopAndDestroy(repository1);
1.2164 + }
1.2165 +
1.2166 +
1.2167 +LOCAL_C void UnloadedPolicyKeyTest()
1.2168 + {
1.2169 + TInt r;
1.2170 + TUint32 KeyId;
1.2171 + CRepository* repository1;
1.2172 +
1.2173 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.2174 +
1.2175 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.2176 + TEST2(r, KErrNone);
1.2177 +
1.2178 + //Creating Single Policy Key
1.2179 + r = repository1->Create(KInt5, KInt5_SecondValue );
1.2180 + TEST2(r,KErrNone);
1.2181 +
1.2182 + //Creating Ranged Policy Key
1.2183 + r = repository1->Create(KInt3, KInt3_InitialValue);
1.2184 + TEST2(r, KErrNone);
1.2185 +
1.2186 + //Creating Default Policy Key
1.2187 + r = repository1->Create(KInt4, KInt4_InitialValue);
1.2188 + TEST2(r,KErrNone);
1.2189 +
1.2190 + //Waiting for enough time for the repository to be evicted
1.2191 + User::After(1000000);
1.2192 +
1.2193 + r = repository1->CommitTransaction(KeyId);
1.2194 + TEST2(r, KErrNone);
1.2195 + TEST2(KeyId, 3);
1.2196 +
1.2197 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.2198 + TEST2(r, KErrNone);
1.2199 +
1.2200 + //Deleting Default Policy Key
1.2201 + r = repository1->Delete(KInt5);
1.2202 + TEST2(r, KErrNone);
1.2203 +
1.2204 + //Deleting Ranged Policy Key
1.2205 + r = repository1->Delete(KInt3);
1.2206 + TEST2(r, KErrNone);
1.2207 +
1.2208 + //Deleting Single Policy Key
1.2209 + r = repository1->Delete(KInt4);
1.2210 + TEST2(r, KErrNone);
1.2211 +
1.2212 + r = repository1->CommitTransaction(KeyId);
1.2213 + TEST2(r, KErrNone);
1.2214 + TEST2(KeyId, 3);
1.2215 +
1.2216 + CleanupStack::PopAndDestroy(repository1);
1.2217 + }
1.2218 +
1.2219 +/**
1.2220 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3239
1.2221 +@SYMTestCaseDesc Test for corrupt access policy when a repository is evicted and reloaded during a transaction
1.2222 +@SYMTestPriority High
1.2223 +@SYMTestActions Start a transaction and create keys with different access policies but evicts the repository prior to commiting it
1.2224 +@SYMTestExpectedResults The test should not fail with any panics
1.2225 +@SYMDEF DEF095718
1.2226 +*/
1.2227 +LOCAL_C void Defect095718()
1.2228 + {
1.2229 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3239 "));
1.2230 + CRepository* repository1;
1.2231 + TInt r;
1.2232 + TUint32 KeyId;
1.2233 + TBuf<KMaxFileName> src1;
1.2234 + TBuf<KMaxFileName> dest1;
1.2235 + _LIT(KDest, "c:\\private\\10202BE9\\centrep.ini");
1.2236 + _LIT(KSrc, "z:\\private\\10202BE9\\centrepcache.ini10");
1.2237 + _LIT( KCentralRepositoryServerName, "Centralrepositorysrv");
1.2238 + const TInt test_total = 3; //The test runs 3 times
1.2239 +
1.2240 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.2241 +
1.2242 + r = repository1->StartTransaction(CRepository::EReadWriteTransaction);
1.2243 + TEST2(r, KErrNone);
1.2244 +
1.2245 + //Deleting the existing key so that we can re-create it later
1.2246 + r = repository1->Delete(KInt5);
1.2247 + TEST2(r, KErrNone);
1.2248 +
1.2249 + r = repository1->CommitTransaction(KeyId);
1.2250 + TEST2(r, KErrNone);
1.2251 + TEST2(KeyId, 1);
1.2252 +
1.2253 + CleanupStack::PopAndDestroy(repository1);
1.2254 +
1.2255 + //Kill the server so that a new .ini file can be loaded when the server restarts
1.2256 + KillProcess(KCentralRepositoryServerName);
1.2257 + //Copy the .ini file from z: to c: so the server will load it
1.2258 + RFs FileServer;
1.2259 + FileServer.Connect();
1.2260 + CleanupClosePushL(FileServer);
1.2261 + CFileMan* fm = CFileMan::NewL(FileServer);
1.2262 + CleanupStack::PushL(fm);
1.2263 + dest1.Copy(KDest);
1.2264 + src1.Copy(KSrc);
1.2265 + r = fm->Delete(dest1);
1.2266 + User::LeaveIfError(fm->Copy(src1,dest1));
1.2267 + r = fm->Attribs(dest1, KEntryAttArchive, KEntryAttReadOnly, TTime(0), CFileMan::ERecurse);
1.2268 + TEST2(r, KErrNone);
1.2269 +
1.2270 + //Test for unloaded policy key a set amount of times
1.2271 + for(TInt i=0; i<test_total; i++)
1.2272 + {
1.2273 + //Check that the policy key used isn't from the unloaded/evicted repository
1.2274 + UnloadedPolicyKeyTest();
1.2275 + }
1.2276 +
1.2277 + //Deleting the ini file so that default values will be used again
1.2278 + r = fm->Delete(dest1);
1.2279 + TEST2(r, KErrNone);
1.2280 +
1.2281 + //Killing the server and restarting it so that default values are loaded
1.2282 + KillProcess(KCentralRepositoryServerName);
1.2283 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.2284 +
1.2285 + CleanupStack::PopAndDestroy(repository1);
1.2286 + CleanupStack::PopAndDestroy(fm);
1.2287 + CleanupStack::PopAndDestroy();
1.2288 + }
1.2289 +
1.2290 +/**
1.2291 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3243
1.2292 +@SYMTestCaseDesc Test that a repository client can be reused after a CommitTransaction and CancelTransaction Operation involving mulitple concurrent transactions
1.2293 +@SYMTestPriority High
1.2294 +@SYMTestExpectedResults The test should not fail with any panics
1.2295 +@SYMTestActions Start concurrent transactions and create keys in each one. Cancel one transaction and commit the others. Then restart the transactions to test for panics
1.2296 +@SYMDEF DEF098242
1.2297 +*/
1.2298 +LOCAL_C void Defect098242()
1.2299 + {
1.2300 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3243 "));
1.2301 + TInt r;
1.2302 + TUint32 KeyId;
1.2303 + CRepository* repository1;
1.2304 + CRepository* repository2;
1.2305 + CRepository* repository3;
1.2306 + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));
1.2307 + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));
1.2308 + User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository));
1.2309 +
1.2310 + //Starting 3 transactions
1.2311 + r = repository1->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.2312 + TEST2(r, KErrNone);
1.2313 +
1.2314 + r = repository2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.2315 + TEST2(r, KErrNone);
1.2316 +
1.2317 + r = repository3->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.2318 + TEST2(r, KErrNone);
1.2319 +
1.2320 + //Adding values in each
1.2321 + r = repository1->Create(KInt2, KInt2_InitialValue);
1.2322 + TEST2(r, KErrNone);
1.2323 +
1.2324 + r = repository2->Create(KInt3, KInt3_InitialValue);
1.2325 + TEST2(r, KErrNone);
1.2326 +
1.2327 + r = repository3->Create(KInt4, KInt4_InitialValue);
1.2328 + TEST2(r, KErrNone);
1.2329 +
1.2330 + //Cancel the transaction of the first client
1.2331 + repository1->CancelTransaction();
1.2332 +
1.2333 + //Committing the other 2 transactions
1.2334 + r = repository2->CommitTransaction(KeyId);
1.2335 + TEST2(r, KErrNone);
1.2336 + TEST2(KeyId,1);
1.2337 +
1.2338 + r = repository3->CommitTransaction(KeyId);
1.2339 + TEST2(r, KErrLocked);
1.2340 + TEST2(KeyId,KUnspecifiedKey);
1.2341 +
1.2342 + //Try Re-starting a transaction with the clients
1.2343 + r = repository1->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.2344 + TEST2(r, KErrNone);
1.2345 + r = repository1->CommitTransaction(KeyId);
1.2346 + TEST2(r, KErrNone);
1.2347 + TEST2(KeyId,0);
1.2348 +
1.2349 + r = repository2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
1.2350 + TEST2(r, KErrNone);
1.2351 +
1.2352 + //Deleting the key so the repository is in the same state as prior to the function call
1.2353 + r = repository2->Delete(KInt3);
1.2354 + TEST2(r, KErrNone);
1.2355 +
1.2356 + //Checking that these values were not made persistent
1.2357 + r = repository2->Delete(KInt2);
1.2358 + TEST2(r, KErrNotFound);
1.2359 +
1.2360 + r = repository2->Delete(KInt4);
1.2361 + TEST2(r, KErrNotFound);
1.2362 +
1.2363 + r = repository2->CommitTransaction(KeyId);
1.2364 + TEST2(r, KErrNone);
1.2365 + TEST2(KeyId,1);
1.2366 +
1.2367 + r = repository1->Reset();
1.2368 + TEST2(r, KErrNone);
1.2369 +
1.2370 + CleanupStack::PopAndDestroy(repository3);
1.2371 + CleanupStack::PopAndDestroy(repository2);
1.2372 + CleanupStack::PopAndDestroy(repository1);
1.2373 + }
1.2374 +
1.2375 +/**
1.2376 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4011
1.2377 +@SYMTestCaseDesc Test for PDEF112273 - When creating commsdat Backup & restore metadata is not set correctly
1.2378 +@SYMTestPriority High
1.2379 +@SYMTestActions The test uses the 00112273.TXT ini file, where the default meta data value is set to be 0x00100000.
1.2380 + The test creates a CRepository object with UID=0x00112273 and creates a single integer setting with
1.2381 + value 1 and no meta data. In this case the setting meta data should be the default one - 0x00100000.
1.2382 + Then the test begins a transaction and within the transaction: the setting gets deleted and then - recreated
1.2383 + again but with a different value and no meta data. The transaction is commited.
1.2384 + The setting meta data value should be 0x00100000 within the transaction and outisde the transaction.
1.2385 +@SYMTestExpectedResults The test should not fail with any panics
1.2386 +@SYMDEF PDEF112273
1.2387 +*/
1.2388 +void DoPDEF112273Test1L()
1.2389 + {
1.2390 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4011 "));
1.2391 + const TUid KTestCenRepUid = {0x00112273};
1.2392 + CRepository* repository = CRepository::NewLC(KTestCenRepUid);
1.2393 + //Create a setting
1.2394 + const TInt KTestSettingId = 123;
1.2395 + TInt err = repository->Create(KTestSettingId, 1);
1.2396 + TEST2(err, KErrNone);
1.2397 +
1.2398 + const TUint32 KDefaultMeta = 0x00100000;
1.2399 + //Check setting meta. The meta value should be KDefaultMeta.
1.2400 + TUint32 meta = 0;
1.2401 + err = repository->GetMeta(KTestSettingId, meta);
1.2402 + TEST2(err, KErrNone);
1.2403 + TEST2(meta, KDefaultMeta);
1.2404 +
1.2405 + err = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.2406 + TEST2(err, KErrNone);
1.2407 + //In a transaction. Delete the created setting.
1.2408 + err = repository->Delete(KTestSettingId);
1.2409 + TEST2(err, KErrNone);
1.2410 + //In a transaction. Re-create the deleted setting but with a different value.
1.2411 + err = repository->Create(KTestSettingId, 2);
1.2412 + TEST2(err, KErrNone);
1.2413 + //In a transaction. Get the setting meta. The meta value should be KDefaultMeta.
1.2414 + err = repository->GetMeta(KTestSettingId, meta);
1.2415 + TEST2(err, KErrNone);
1.2416 + TEST2(meta, KDefaultMeta);
1.2417 +
1.2418 + TUint32 keyInfo = 0;
1.2419 + err = repository->CommitTransaction(keyInfo);
1.2420 + TEST2(err, KErrNone);
1.2421 +
1.2422 + //Not in transaction. Get the setting meta. The meta value should be KDefaultMeta.
1.2423 + err = repository->GetMeta(KTestSettingId, meta);
1.2424 + TEST2(err, KErrNone);
1.2425 + TEST2(meta, KDefaultMeta);
1.2426 +
1.2427 + CleanupStack::PopAndDestroy(repository);
1.2428 + }
1.2429 +
1.2430 +/**
1.2431 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4012
1.2432 +@SYMTestCaseDesc Test for PDEF112273 - When creating commsdat Backup & restore metadata is not set correctly
1.2433 +@SYMTestPriority High
1.2434 +@SYMTestActions The test uses the 00112273.TXT ini file, where the default meta data value is set to be 0x00100000.
1.2435 + The test creates a CRepository object with UID=0x00112273.
1.2436 + Then the test begins a transaction and within the transaction: setting with id=0x0000001 (from the ini file)
1.2437 + and setting meta=0x00200000 will be deleted and then recreated again with a different value and no meta.
1.2438 + The transaction is commited.
1.2439 + The setting meta data value should be 0x00200000 within the transaction and outisde the transaction.
1.2440 +@SYMTestExpectedResults The test should not fail with any panics
1.2441 +@SYMDEF PDEF112273
1.2442 +*/
1.2443 +void DoPDEF112273Test2L()
1.2444 + {
1.2445 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4012 "));
1.2446 + const TUid KTestCenRepUid = {0x00112273};
1.2447 + CRepository* repository = CRepository::NewLC(KTestCenRepUid);
1.2448 + //Ini file - KTestSettingId setting properties:
1.2449 + const TInt KTestSettingId = 0x0000001;
1.2450 + const TInt KTestSettingVal = 1;
1.2451 + const TUint32 KSettingMeta = 0x00200000;
1.2452 + //Check setting meta. The meta value should be KDefaultMeta.
1.2453 + TUint32 meta = 0;
1.2454 + TInt err = repository->GetMeta(KTestSettingId, meta);
1.2455 + TEST2(err, KErrNone);
1.2456 + TEST2(meta, KSettingMeta);
1.2457 +
1.2458 + err = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.2459 + TEST2(err, KErrNone);
1.2460 + //In a transaction. Delete the created setting.
1.2461 + err = repository->Delete(KTestSettingId);
1.2462 + TEST2(err, KErrNone);
1.2463 + //In a transaction. Re-create the deleted setting with different value.
1.2464 + err = repository->Create(KTestSettingId, KTestSettingVal + 1);
1.2465 + TEST2(err, KErrNone);
1.2466 + //In a transaction. Get the setting meta. The meta value should be KSettingMeta.
1.2467 + err = repository->GetMeta(KTestSettingId, meta);
1.2468 + TEST2(err, KErrNone);
1.2469 + TEST2(meta, KSettingMeta);
1.2470 +
1.2471 + TUint32 keyInfo = 0;
1.2472 + err = repository->CommitTransaction(keyInfo);
1.2473 + TEST2(err, KErrNone);
1.2474 +
1.2475 + //Not in transaction. Get the setting meta. The meta value should be KSettingMeta.
1.2476 + err = repository->GetMeta(KTestSettingId, meta);
1.2477 + TEST2(err, KErrNone);
1.2478 + TEST2(meta, KSettingMeta);
1.2479 +
1.2480 + CleanupStack::PopAndDestroy(repository);
1.2481 + }
1.2482 +
1.2483 +/**
1.2484 +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4013
1.2485 +@SYMTestCaseDesc Test for PDEF112273 - When creating commsdat Backup & restore metadata is not set correctly
1.2486 +@SYMTestPriority High
1.2487 +@SYMTestActions The test uses the 00112273.TXT ini file, where the default meta data value is set to be 0x00100000.
1.2488 + The test creates a CRepository object with UID=0x00112273.
1.2489 + Then the test begins a transaction and within the transaction: a new setting with no meta is created.
1.2490 + The transaction is commited.
1.2491 + The setting meta data value should be 0x00100000 within the transaction and outisde the transaction.
1.2492 +@SYMTestExpectedResults The test should not fail with any panics
1.2493 +@SYMDEF PDEF112273
1.2494 +*/
1.2495 +void DoPDEF112273Test3L()
1.2496 + {
1.2497 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4013 "));
1.2498 + const TUid KTestCenRepUid = {0x00112273};
1.2499 + CRepository* repository = CRepository::NewLC(KTestCenRepUid);
1.2500 +
1.2501 + TInt err = repository->StartTransaction(CRepository::EReadWriteTransaction);
1.2502 + TEST2(err, KErrNone);
1.2503 + //In a transaction. Create a setting
1.2504 + const TInt KTestSettingId = 1234;
1.2505 + err = repository->Create(KTestSettingId, 1);
1.2506 + TEST2(err, KErrNone);
1.2507 +
1.2508 + const TUint32 KDefaultMeta = 0x00100000;
1.2509 + TUint32 meta = 0;
1.2510 + //In a transaction. Get the setting meta. The meta value should be KDefaultMeta.
1.2511 + err = repository->GetMeta(KTestSettingId, meta);
1.2512 + TEST2(err, KErrNone);
1.2513 + TEST2(meta, KDefaultMeta);
1.2514 +
1.2515 + TUint32 keyInfo = 0;
1.2516 + err = repository->CommitTransaction(keyInfo);
1.2517 + TEST2(err, KErrNone);
1.2518 +
1.2519 + //Not in transaction. Get the setting meta. The meta value should be KDefaultMeta.
1.2520 + err = repository->GetMeta(KTestSettingId, meta);
1.2521 + TEST2(err, KErrNone);
1.2522 + TEST2(meta, KDefaultMeta);
1.2523 +
1.2524 + CleanupStack::PopAndDestroy(repository);
1.2525 + }
1.2526 +
1.2527 +void PDEF112273L()
1.2528 + {
1.2529 + DoPDEF112273Test1L();
1.2530 + DoPDEF112273Test2L();
1.2531 + DoPDEF112273Test3L();
1.2532 + }
1.2533 +
1.2534 +LOCAL_C void TransactionsFuncTestsL()
1.2535 + {
1.2536 + TheTest.Next(_L("Committing changes causes other sessions' active transactions to fail with KErrLocked"));
1.2537 + CommittingChangesFailsOtherTransactionsL();
1.2538 +
1.2539 + TheTest.Next(_L("Committing no changes does not fail other sessions' active transactions"));
1.2540 + CommittingNoChangesDoesNotFailOtherTransactionsL();
1.2541 +
1.2542 + TheTest.Start(_L("Create values using transaction"));
1.2543 + CreateValueUsingTransactionL();
1.2544 +
1.2545 + TheTest.Next(_L("Get transaction state in transactions and test for rollback in failed transactions"));
1.2546 + TransactionStateAndRollBackL();
1.2547 +
1.2548 + TheTest.Next(_L("Multiple Read-Write Transaction error and panic conditions"));
1.2549 + TransactionPanicConditionsThread();
1.2550 +
1.2551 + TheTest.Next(_L("Commit Transaction error and panic condition"));
1.2552 + CommitTransactionPanicConditionsThread();
1.2553 +
1.2554 + TheTest.Next(_L("Clean up using rollback and failed transactions"));
1.2555 + CleanupRollBackAndFailTransactionL();
1.2556 +
1.2557 + TheTest.Next(_L("Multiple Read Transaction conditions"));
1.2558 + ReadTransactionConditionsL();
1.2559 +
1.2560 + TheTest.Next(_L("Multiple Read Transaction with upgrade error conditions"));
1.2561 + UpgradeReadTransactionErrorConditionsL();
1.2562 +
1.2563 + TheTest.Next(_L("Transaction conditions with read operations"));
1.2564 + TransactionConditionsForReadL();
1.2565 +
1.2566 + TheTest.Next(_L("Transaction error conditions with get operations"));
1.2567 + TransactionErrorConditionsForGetL();
1.2568 +
1.2569 + TheTest.Next(_L("Transaction error conditions with find operations"));
1.2570 + TransactionErrorConditionsForFindL();
1.2571 +
1.2572 + TheTest.Next(_L("Transaction error conditions with findeq operations"));
1.2573 + TransactionErrorConditionsForFindEqL();
1.2574 +
1.2575 + TheTest.Next(_L("Transaction error conditions with findneq operations"));
1.2576 + TransactionErrorConditionsForFindNeqL();
1.2577 +
1.2578 + TheTest.Next(_L("Transaction error conditions with create operations"));
1.2579 + TransactionErrorConditionsForCreateL();
1.2580 +
1.2581 + TheTest.Next(_L("Transaction error conditions with delete operations"));
1.2582 + TransactionErrorConditionsForDeleteL();
1.2583 +
1.2584 + TheTest.Next(_L("Transaction error conditions with set operations"));
1.2585 + TransactionErrorConditionsForSetL();
1.2586 +
1.2587 + TheTest.Next(_L("Transaction error conditions with move operations"));
1.2588 + TransactionErrorConditionsForMoveL();
1.2589 +
1.2590 + TheTest.Next(_L("Transaction conditions with move operations"));
1.2591 + TransactionConditionsForMoveL();
1.2592 +
1.2593 + // Concurrent read/write transactions...
1.2594 +
1.2595 + TheTest.Next(_L("Concurrent read/write transaction"));
1.2596 + ConcurrentReadWriteTransactionStatesL();
1.2597 +
1.2598 + TheTest.Next(_L("Concurrent read/write transaction with other reads operations"));
1.2599 + ConcurrentReadWriteTransactionWithReadOperationsL();
1.2600 +
1.2601 + // Test cases for defects ...
1.2602 +
1.2603 + TheTest.Next(_L("Tests for get functions, as required in DEF058796"));
1.2604 + Defect058796();
1.2605 +
1.2606 + TheTest.Next(_L("Checks for corrupt policy keys, as required in DEF095718"));
1.2607 + Defect095718();
1.2608 +
1.2609 + TheTest.Next(_L("Test for restarting a transaction from the same client, as required in DEF098242"));
1.2610 + Defect098242();
1.2611 +
1.2612 + TheTest.Next(_L("PDEF112273 - When creating commsdat Backup & restore metadata is not set correctly"));
1.2613 + PDEF112273L();
1.2614 +
1.2615 + TheTest.End();
1.2616 + }
1.2617 +
1.2618 +LOCAL_C void MainL()
1.2619 + {
1.2620 + TheTest.Start(_L("Central Repository transactions functional tests"));
1.2621 + CleanupCDriveL();
1.2622 + TransactionsFuncTestsL();
1.2623 +
1.2624 + TheTest.Next(_L("Clean out C: files"));
1.2625 + CleanupCDriveL();
1.2626 +
1.2627 + TheTest.End();
1.2628 + TheTest.Close();
1.2629 + }
1.2630 +
1.2631 +TInt E32Main()
1.2632 + {
1.2633 + __UHEAP_MARK;
1.2634 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.2635 + if(!cleanup)
1.2636 + return KErrNoMemory;
1.2637 +
1.2638 + TRAPD(err, MainL());
1.2639 + if (err != KErrNone)
1.2640 + User::Panic(_L("Testing failed: "), err);
1.2641 +
1.2642 + delete cleanup;
1.2643 + __UHEAP_MARKEND;
1.2644 +
1.2645 + return 0;
1.2646 + }
1.2647 +