Symaptic: os/persistentdata/persistentstorage/centralrepository/test/t_cenrep

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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include "t_cenrep_helper.h"

    17 #include <centralrepository.h>

    18 #include <e32test.h>

    19 #include <f32file.h>

    20 #include <bautils.h>

    21 #include "e32math.h"

    22 #include "srvparams.h"

    23 #include "transstate.h"

    24 #include "clientrequest.h"

    25 #include "panic.h"

    27 //#define Additional_Test

    29 using namespace NCentralRepositoryConstants;

    31 RTest TheTest(_L("Central Repository Transaction Tests"));

    33 const TUid KUidTestRepository 	= { 0x0000101 };

    35 //

    36 // Repository A

    37 //

    39 const TUint32 KUnprotectedSettingsMask = 0xFF000000 ;

    41 const TInt KThreadStackSize	=0x2000; // 8k

    42 const TInt KThreadMinHeapSize	=0x4000; // 16k

    43 const TInt KThreadMaxHeapSize	=0xa000; // 60k

    45 const TUint32 KInt1 = 1;

    46 const TInt KInt1_InitialValue = 1;

    48 const TUint32 KReal1 = 2;

    49 const TReal KReal1_InitialValue = 2.732;

    50 const TUint32 KString8 = 5;

    51 const TUint32 KString16 = 6;

    52 _LIT(KString16_InitialValue, "test\\\"string\"");

    53 _LIT8(KString8_InitialValue, "test\\\"string\"");

    55 const TInt KInt2 = 3;

    56 const TInt KInt2_InitialValue = 20;

    57 const TUint32 KReal2 = 28;

    58 const TReal KReal2_InitialValue = 2.5;

    59 const TReal KReal2_SecondValue = 3.5;

    60 const TUint32 KNewString8 = 21;

    61 const TUint32 KNewString16 = 22;

    62 _LIT(KString16_InitialValue2, "another\\\"string\"");

    63 _LIT8(KString8_InitialValue2, "another\\\"string\"");

    65 _LIT(KString16_Small_Value, "te");

    66 _LIT8(KString8_Small_Value, "te");

    68 const TUint32 KMoveTarget            = 0x02000001  ;

    69 const TUint32 KMoveSourceDoesntExist = 0x01000000 ;

    70 const TUint32 KMoveMask              = 0xFF0000FF ;

    72 const TUint32 KInt3 = 10; //Ranged Policy Key

    73 const TInt KInt3_InitialValue = 34;

    74 const TUint32 KInt4 = 0x201; //Default Policy Key

    75 const TInt KInt4_InitialValue = 10;

    76 const TUint32 KInt5 = 0x1000001; //Single Policy Key

    77 const TInt KInt5_SecondValue = 123;

    78 ///////////////////////////////////////////////////////////////////////////////////////

    79 ///////////////////////////////////////////////////////////////////////////////////////

    80 //Test macroses and functions

    81 LOCAL_C void CheckL(TInt aValue, TInt aLine)

    82 	{

    83 	if(!aValue)

    84 		{

    85 		CleanupCDriveL();

    86 		TheTest(EFalse, aLine);

    87 		}

    88 	}

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

    90 	{

    91 	if(aValue != aExpected)

    92 		{

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

    94 		CleanupCDriveL();

    95 		TheTest(EFalse, aLine);

    96 		}

    97 	}

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

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

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

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

   104 typedef void (*TRepositoryFunc)(CRepository&);

   106 void ChangeByCreate(CRepository& aRep)

   107 	{

   108 	TInt r;

   109 	// Create a setting outside of a transaction

   110 	r = aRep.Create(KReal2, KReal2_InitialValue);

   111 	TEST2(r, KErrNone);

   112 	// confirm setting created

   113 	TReal value;

   114 	r = aRep.Get(KReal2, value);

   115 	TEST2(r, KErrNone);

   116 	TEST(value == KReal2_InitialValue);

   117 	}

   119 void ChangeBySet(CRepository& aRep)

   120 	{

   121 	TInt r;

   122 	// Set a value outside of a transaction

   123 	r = aRep.Set(KReal2, KReal2_SecondValue);

   124 	TEST2(r, KErrNone);

   125 	// confirm value changed

   126 	TReal value;

   127 	r = aRep.Get(KReal2, value);

   128 	TEST2(r, KErrNone);

   129 	TEST(value == KReal2_SecondValue);

   130 	}

   132 void ChangeByDelete(CRepository& aRep)

   133 	{

   134 	TInt r;

   135 	// Delete a setting outside of a transaction

   136 	r = aRep.Delete(KReal2);

   137 	TEST2(r, KErrNone);

   138 	// confirm it's deleted

   139 	TReal value;

   140 	r = aRep.Get(KReal2, value);

   141 	TEST2(r, KErrNotFound);

   142 	}

   144 void ChangeByTransaction(CRepository& aRep)

   145 	{

   146 	TInt r;

   147 	TUint32 keyInfo;

   149 	// Lock should prevent ERead/WriteTransactions from being able to start from

   150 	// within function CommittingChangesFailsOtherTransactions.

   151 	r = aRep.StartTransaction(CRepository::EReadWriteTransaction);

   152 	TEST2(r, KErrLocked);

   153 	r = aRep.StartTransaction(CRepository::EReadTransaction);

   154 	TEST2(r, KErrLocked);

   156 	// Concurrent Read/Write transactions can be opened at any time

   157 	r = aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction);

   158 	TEST2(r, KErrNone);

   159 	r = TransactionState(&aRep);

   160 	TEST2(r, EConcurrentReadWriteTransaction);

   162 	// Create a setting within transaction

   163 	r = aRep.Create(KReal2, KReal2_InitialValue);

   164 	TEST2(r, KErrNone);

   165 	// confirm setting created

   166 	TReal value;

   167 	r = aRep.Get(KReal2, value);

   168 	TEST2(r, KErrNone);

   169 	TEST(value == KReal2_InitialValue);

   171 	r = aRep.CommitTransaction(keyInfo);

   172 	TEST2(r, KErrNone);

   173 	TEST2(keyInfo, 1); // 1 successful change

   175 	// re-confirm setting is still there

   176 	r = aRep.Get(KReal2, value);

   177 	TEST2(r, KErrNone);

   178 	TEST(value == KReal2_InitialValue);

   179 	}

   181 // checking that async start and commit, with WaitForRequest do same as ChangeByTransaction

   182 void ChangeByAsyncTransaction(CRepository& aRep)

   183 	{

   184 	TInt r;

   185 	CRepository::TTransactionKeyInfoBuf keyInfoBuf;

   186 	TRequestStatus status;

   188 	// Lock should prevent ERead/WriteTransactions from being able to start from

   189 	// within function CommittingChangesFailsOtherTransactions.

   190 	aRep.StartTransaction(CRepository::EReadWriteTransaction, status);

   191 	User::WaitForRequest(status);

   192 	TEST2(status.Int(), KErrLocked);

   193 	aRep.StartTransaction(CRepository::EReadTransaction, status);

   194 	User::WaitForRequest(status);

   195 	TEST2(status.Int(), KErrLocked);

   197 	// Concurrent Read/Write transactions can be opened at any time

   198 	aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction, status);

   199 	// can't predict whether status will be KRequestPending at this time, so don't check

   200 	User::WaitForRequest(status);

   201 	TEST2(status.Int(), KErrNone);

   202 	r = TransactionState(&aRep);

   203 	TEST2(r, EConcurrentReadWriteTransaction);

   205 	// Create a setting within transaction

   206 	r = aRep.Create(KReal2, KReal2_InitialValue);

   207 	TEST2(r, KErrNone);

   208 	// confirm setting created

   209 	TReal value;

   210 	r = aRep.Get(KReal2, value);

   211 	TEST2(r, KErrNone);

   212 	TEST(value == KReal2_InitialValue);

   214 	aRep.CommitTransaction(keyInfoBuf, status);

   215 	User::WaitForRequest(status);

   216 	TEST2(status.Int(), KErrNone);

   217 	TEST2(keyInfoBuf(), 1); // 1 successful change

   219 	// re-confirm setting is still there

   220 	r = aRep.Get(KReal2, value);

   221 	TEST2(r, KErrNone);

   222 	TEST(value == KReal2_InitialValue);

   223 	}

   225 void ChangeByReset(CRepository& aRep)

   226 	{

   227 	TInt r;

   228 	// Delete a setting outside of a transaction

   229 	r = aRep.Reset(KReal2);

   230 	TEST2(r, KErrNone);

   231 	// confirm it's reset (should be deleted)

   232 	TReal value;

   233 	r = aRep.Get(KReal2, value);

   234 	TEST2(r, KErrNotFound);

   235 	}

   237 void ChangeByResetAll(CRepository& aRep)

   238 	{

   239 	TInt r;

   240 	// Delete a setting outside of a transaction

   241 	r = aRep.Reset();

   242 	TEST2(r, KErrNone);

   243 	// confirm it's reset (should be deleted)

   244 	TReal value;

   245 	r = aRep.Get(KReal2, value);

   246 	TEST2(r, KErrNotFound);

   247 	}

   249 // tests that changes made by calling ChangeFunc with aCommittingRepository fail active

   250 // transactions with reason KErrLocked, and correctly discard changes

   251 LOCAL_C void CallFuncCheckOtherTransactionsFail(TRepositoryFunc ChangeFunc, CRepository& aCommittingRepository)

   252 	{

   253 	TInt r;

   254 	TUint32 keyInfo;

   255 	CRepository* repository1;

   256 	CRepository* repository2;

   258 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

   259 	User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));

   261 	// Start two types of transaction

   262 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

   263 	TEST2(r, KErrNone);

   264 	r = repository2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

   265 	TEST2(r, KErrNone);

   267 	// check transactions haven't failed yet.

   268 	r = TransactionState(repository1);

   269 	TEST2(r, EReadWriteTransaction);

   270 	r = TransactionState(repository2);

   271 	TEST2(r, EConcurrentReadWriteTransaction);

   273 	// create a value in repository2's transaction and check it is there

   274 	r = repository2->Create(KInt1, KInt1_InitialValue);

   275 	TEST2(r, KErrNone);

   276 	TInt value;

   277 	r = repository2->Get(KInt1, value);

   278 	TEST2(r, KErrNone);

   279 	TEST(value == KInt1_InitialValue);

   281 	(*ChangeFunc)(aCommittingRepository);

   283 	// check transactions have now failed

   284 	r = TransactionState(repository1);

   285 	TEST2(r, EReadWriteTransaction | EFailedBit);

   286 	r = TransactionState(repository2);

   287 	TEST2(r, EConcurrentReadWriteTransaction | EFailedBit);

   289 	// operations should abort after failing

   290 	r = repository2->Get(KInt1, value);

   291 	TEST2(r, KErrAbort);

   292 	r = repository1->Set(KInt1, value);

   293 	TEST2(r, KErrAbort);

   295 	// commits should fail with KErrLocked

   296 	r = repository2->CommitTransaction(keyInfo);

   297 	TEST2(r, KErrLocked);

   298 	TEST2(keyInfo, KUnspecifiedKey);

   299 	r = repository1->CommitTransaction(keyInfo);

   300 	TEST2(r, KErrLocked);

   301 	TEST2(keyInfo, KUnspecifiedKey);

   303 	// integer should not be persistent

   304 	r = repository2->Get(KInt1, value);

   305 	TEST2(r, KErrNotFound);

   307 	CleanupStack::PopAndDestroy(repository2);

   308 	CleanupStack::PopAndDestroy(repository1);

   309 	}

   311 /**

   312 @SYMTestCaseID SYSLIB-CENREP-CT-0150

   313 @SYMTestCaseDesc Check committing changes causes other transactions to fail.

   314 @SYMTestPriority High

   315 @SYMTestActions Run a series of commands that modify repository, check they fail active transactions.

   316  Start concurrent read write transaction and try to create and get values using other repository.

   317 @SYMTestExpectedResults The test should not fail with any panics

   318 @SYMPREQ PREQ752

   319 */

   320 LOCAL_C void CommittingChangesFailsOtherTransactionsL()

   321 	{

   322 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0150 "));

   323 	CRepository* repository;

   325 	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));

   327 	repository->Reset();

   329 	// non-transaction create should fail active transactions

   330 	CallFuncCheckOtherTransactionsFail(ChangeByCreate, *repository);

   332 	// non-transaction set should fail active transactions

   333 	CallFuncCheckOtherTransactionsFail(ChangeBySet, *repository);

   335 	// non-transaction delete should fail active transactions

   336 	CallFuncCheckOtherTransactionsFail(ChangeByDelete, *repository);

   338 	// transaction commit with changes should fail active transactions

   339 	CallFuncCheckOtherTransactionsFail(ChangeByTransaction, *repository);

   341 	ChangeByDelete(*repository); // just to ready for next test

   343 	// async started and committed transaction with changes should fail active transactions

   344 	CallFuncCheckOtherTransactionsFail(ChangeByAsyncTransaction, *repository);

   346 	// individual reset that has an effect should fail active transactions

   347 	CallFuncCheckOtherTransactionsFail(ChangeByReset, *repository);

   349 	ChangeByCreate(*repository); // just to ready for next test

   351 	// reset all should fail active transactions

   352 	CallFuncCheckOtherTransactionsFail(ChangeByResetAll, *repository);

   354 	CleanupStack::PopAndDestroy(repository);

   355 	}

   357 void NoChangeByTransactionCreateDelete(CRepository& aRep)

   358 	{

   359 	TInt r;

   360 	TUint32 keyInfo;

   361 	// Concurrent Read/Write transactions can be opened at any time

   362 	r = aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction);

   363 	TEST2(r, KErrNone);

   364 	r = TransactionState(&aRep);

   365 	TEST2(r, EConcurrentReadWriteTransaction);

   366 	// deleting the setting that was just added should result in no change when committing:

   367 	ChangeByCreate(aRep);

   368 	ChangeByDelete(aRep);

   369 	r = aRep.CommitTransaction(keyInfo);

   370 	TEST2(r, KErrNone);

   371 	TEST2(keyInfo, 0); // no changes

   372 	}

   374 void NoChangeByTransactionSetSameValue(CRepository& aRep)

   375 	{

   376 	TInt r;

   377 	TUint32 keyInfo;

   378 	// Concurrent Read/Write transactions can be opened at any time

   379 	r = aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction);

   380 	TEST2(r, KErrNone);

   381 	r = TransactionState(&aRep);

   382 	TEST2(r, EConcurrentReadWriteTransaction);

   383 	// changing setting to the value it already has should result in no change when committing:

   384 	ChangeBySet(aRep);

   385 	r = aRep.CommitTransaction(keyInfo);

   386 	TEST2(r, KErrNone);

   387 	TEST2(keyInfo, 0); // no changes

   388 	}

   390 void NoChangeByReadTransaction(CRepository& aRep)

   391 	{

   392 	TInt r;

   393 	TUint32 keyInfo;

   394 	// Read transactions can be opened now because there is no EReadWriteTransaction open

   395 	r = aRep.StartTransaction(CRepository::EReadTransaction);

   396 	TEST2(r, KErrNone);

   397 	r = TransactionState(&aRep);

   398 	TEST2(r, EReadTransaction);

   399 	// Getting a value should result in no change when committing:

   400 	TReal value;

   401 	r = aRep.Get(KReal2, value);

   402 	TEST2(r, KErrNone);

   403 	TEST(value == KReal2_InitialValue);

   404 	r = aRep.CommitTransaction(keyInfo);

   405 	TEST2(r, KErrNone);

   406 	TEST2(keyInfo, 0); // no changes

   407 	}

   409 void NoChangeByEmptyWriteTransaction(CRepository& aRep)

   410 	{

   411 	TInt r;

   412 	TUint32 keyInfo;

   413 	// can't start an EReadWriteTransaction because a ReadTransaction is active

   414 	r = aRep.StartTransaction(CRepository::EReadWriteTransaction);

   415 	TEST2(r, KErrLocked);

   416 	// Concurrent Read/Write transactions can be opened at any time

   417 	r = aRep.StartTransaction(CRepository::EConcurrentReadWriteTransaction);

   418 	TEST2(r, KErrNone);

   419 	r = TransactionState(&aRep);

   420 	TEST2(r, EConcurrentReadWriteTransaction);

   421 	// make no changes before committing

   422 	r = aRep.CommitTransaction(keyInfo);

   423 	TEST2(r, KErrNone);

   424 	TEST2(keyInfo, 0); // no changes

   425 	}

   427 // tests that changes made by calling ChangeFunc with aCommittingRepository

   428 // do not fail active transactions. Must Reset before calling this.

   429 LOCAL_C void CallFuncCheckOtherTransactionsDoNotFail(TRepositoryFunc ChangeFunc, CRepository& aCommittingRepository)

   430 	{

   431 	TInt r;

   432 	CRepository::TTransactionKeyInfoBuf keyInfoBuf;

   433 	TUint32 keyInfo;

   434 	TRequestStatus status;

   435 	CRepository* repository1;

   436 	CRepository* repository2;

   438 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

   439 	User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));

   441 	// Start two types of transaction and wait for completion

   442 	r = repository1->StartTransaction(CRepository::EReadTransaction);

   443 	TEST2(r, KErrNone);

   444 	repository2->StartTransaction(CRepository::EConcurrentReadWriteTransaction, status);

   445 	User::WaitForRequest(status);

   446 	TEST2(status.Int(), KErrNone);

   448 	// create values in repository2's transaction cache

   449 	r = repository2->Create(KNewString8, KString8_InitialValue);

   450 	TEST2(r, KErrNone);

   451 	r = repository2->Create(KNewString16, KString16_InitialValue);

   452 	TEST2(r, KErrNone);

   454 	// check transactions not failed

   455 	r = TransactionState(repository1);

   456 	TEST2(r, EReadTransaction);

   457 	r = TransactionState(repository2);

   458 	TEST2(r, EConcurrentReadWriteTransaction);

   460 	(*ChangeFunc)(aCommittingRepository);

   462 	// create setting in repository 1's cache

   463 	r = repository1->Create(KInt2, KInt2_InitialValue);

   464 	TEST2(r, KErrNone);

   466 	// check transactions not failed & Read upgraded to ReadWrite

   467 	r = TransactionState(repository1);

   468 	TEST2(r, EReadWriteTransaction);

   469 	r = TransactionState(repository2);

   470 	TEST2(r, EConcurrentReadWriteTransaction);

   472 	// commit repository2 asynchronously

   473 	repository2->CommitTransaction(keyInfoBuf, status);

   474 	User::WaitForRequest(status);

   475 	TEST2(status.Int(), KErrNone);

   476 	TEST2(keyInfoBuf(), 2); // 2 successful changes

   478 	// check transaction2 finished, transaction 1 failed

   479 	r = TransactionState(repository1);

   480 	TEST2(r, EReadWriteTransaction | EFailedBit);

   481 	r = TransactionState(repository2);

   482 	TEST2(r, ENoTransaction);

   484 	// operations on repository 1 should abort after failing

   485 	TInt intValue;

   486 	r = repository1->Get(KInt1, intValue);

   487 	TEST2(r, KErrAbort);

   488 	r = repository1->Set(KInt1, intValue);

   489 	TEST2(r, KErrAbort);

   491 	// commit of repository 1 should fail with KErrLocked

   492 	r = repository1->CommitTransaction(keyInfo);

   493 	TEST2(r, KErrLocked);

   494 	TEST2(keyInfo, KUnspecifiedKey);

   496 	// check changes by repository 2 are still present

   497 	TBuf8<40> buf8Value;

   498 	TBuf16<40> buf16Value;

   500 	r = repository2->Get(KNewString8, buf8Value);

   501 	TEST2(r, KErrNone);

   502 	TEST(buf8Value == KString8_InitialValue);

   503 	r = repository2->Get(KNewString16, buf16Value);

   504 	TEST2(r, KErrNone);

   505 	TEST(buf16Value == KString16_InitialValue);

   507 	CleanupStack::PopAndDestroy(repository2);

   508 	CleanupStack::PopAndDestroy(repository1);

   509 	}

   511 /**

   512 @SYMTestCaseID SYSLIB-CENREP-CT-0151

   513 @SYMTestCaseDesc Check committing no changes (incl. setting same value) does not cause other transactions to fail.

   514 @SYMTestPriority High

   515 @SYMTestActions Run a series of commands that modify repository, check they fail active transactions.

   516  Start concurrent read write transaction and try to create and get values using other repository.

   517 @SYMTestExpectedResults The test should not fail with any panics

   518 @SYMPREQ PREQ752

   519 */

   520 LOCAL_C void CommittingNoChangesDoesNotFailOtherTransactionsL()

   521 	{

   522 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0151 "));

   523 	CRepository* repository;

   525 	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));

   527 	// creating and deleting the same setting in the same transaction should have no effect

   528 	repository->Reset();

   529 	CallFuncCheckOtherTransactionsDoNotFail(NoChangeByTransactionCreateDelete, *repository);

   531 	// changing a setting to the same value in a transaction should have no effect

   532 	repository->Reset();

   533 	ChangeByCreate(*repository);

   534 	ChangeBySet(*repository);

   535 	CallFuncCheckOtherTransactionsDoNotFail(NoChangeByTransactionSetSameValue, *repository);

   537 	// committing a Read transaction should have no effect

   538 	repository->Reset();

   539 	ChangeByCreate(*repository);

   540 	CallFuncCheckOtherTransactionsDoNotFail(NoChangeByReadTransaction, *repository);

   542 	// committing an empty transaction should have no effect

   543 	repository->Reset();

   544 	CallFuncCheckOtherTransactionsDoNotFail(NoChangeByEmptyWriteTransaction, *repository);

   546 	CleanupStack::PopAndDestroy(repository);

   548 	// restart session and check values are indeed saved

   549 	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));

   551 	TInt r;

   552 	TBuf8<40> buf8Value;

   553 	TBuf16<40> buf16Value;

   554 	r = repository->Get(KNewString8, buf8Value);

   555 	TEST2(r, KErrNone);

   556 	TEST(buf8Value == KString8_InitialValue);

   557 	r = repository->Get(KNewString16, buf16Value);

   558 	TEST2(r, KErrNone);

   559 	TEST(buf16Value == KString16_InitialValue);

   560 	// final cleanup

   561 	repository->Reset();

   563 	CleanupStack::PopAndDestroy(repository);

   564 	}

   566 /**

   567 @SYMTestCaseID SYSLIB-CENREP-CT-0152

   568 @SYMTestCaseDesc Testing creates in a read write transaction

   569 @SYMTestPriority High

   570 @SYMTestActions  Starts a read write transaction which creates values for KInt1, KReal1, KString8 and KString16

   571 @SYMTestExpectedResults The test should not fail with any panics

   572 @SYMPREQ PREQ752

   573 */

   574 LOCAL_C void CreateValueUsingTransactionL()

   575 	{

   576 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0152 "));

   577 	TInt r;

   578 	TUint32 errorId;

   580 	CRepository* repository;

   581 	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));

   583 	// Begin read write transaction

   584 	r = repository->StartTransaction(CRepository::EReadWriteTransaction);

   585 	TEST2(r, KErrNone);

   587 	r = repository->Create(KInt1, KInt1_InitialValue);

   588 	TEST2(r, KErrNone);

   590 	r = repository->Create(KReal1, KReal1_InitialValue);

   591 	TEST2(r, KErrNone);

   593 	r = repository->Create(KString8, KString8_InitialValue);

   594 	TEST2(r, KErrNone);

   596 	r = repository->Create(KString16, KString16_InitialValue);

   597 	TEST2(r, KErrNone);

   599 	// Commit transaction

   600 	r = repository->CommitTransaction(errorId);

   601 	TEST2(r, KErrNone);

   602 	// Test for the value of errorId for a successful read write transaction = 4 changes

   603 	TEST2(errorId, 4);

   605 	CleanupStack::PopAndDestroy(repository);

   607 	}

   609 /**

   610 @SYMTestCaseID SYSLIB-CENREP-CT-0153

   611 @SYMTestCaseDesc Testing state and rollback in a transaction

   612 @SYMTestPriority High

   613 @SYMTestActions  Use both transactionstate and failtransaction while being in a transaction and not in a transaction.

   614 	Check on the state and test to see if rollback occurs when required.

   615 @SYMTestExpectedResults The test should not fail with any panics

   616 @SYMPREQ PREQ752

   617 */

   618 LOCAL_C void TransactionStateAndRollBackL()

   619 	{

   620 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0153 "));

   621 	TInt r;

   622 	TUint32 errorId;

   623 	TReal getValue;

   625 	CRepository* repository;

   626 	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));

   628 	r = TransactionState(repository);

   629 	TEST2(r, ENoTransaction);

   631 	// Try to fail transaction without being in a transaction

   632 	repository->FailTransaction();

   634 	r = TransactionState(repository);

   635 	TEST2(r, ENoTransaction);

   637 	// Begin concurrent read write transaction

   638 	r = repository->StartTransaction(CRepository::EReadWriteTransaction);

   639 	TEST2(r, KErrNone);

   641 	r = TransactionState(repository);

   642 	TEST2(r, EReadWriteTransaction);

   644 	r = repository->Create(KReal2, KReal2_InitialValue);

   645 	TEST2(r, KErrNone);

   647 	r = repository->Get(KReal2, getValue);

   648 	TEST(getValue == KReal2_InitialValue);

   649 	TEST2(r, KErrNone);

   651 	// Fail transaction should roll back transaction i.e. Create KReal2 should not work.

   652 	repository->FailTransaction();

   654 	r = TransactionState(repository);

   655 	TEST2(r, EReadWriteTransaction | EFailedBit);

   657 	// Commit transaction

   658 	r = repository->CommitTransaction(errorId);

   659 	TEST2(r, KErrAbort);

   660 	// Test the value of errorId for a failed read write transaction

   661 	TEST2(errorId, KUnspecifiedKey);

   663 	// Try to get a value which should not exist as transaction failed

   664 	r = repository->Get(KReal2, getValue);

   665 	TEST2(r, KErrNotFound);

   667 	r = TransactionState(repository);

   668 	TEST2(r, ENoTransaction);

   670 	r = repository->StartTransaction(CRepository::EReadWriteTransaction);

   671 	TEST2(r, KErrNone);

   673 	r = repository->Create(KReal2, KReal2_InitialValue);

   674 	TEST2(r, KErrNone);

   676 	repository->RollbackTransaction();

   678 	// Try to get a value which should not exist as transaction rolled back

   679 	r = repository->Get(KReal2, getValue);

   680 	TEST2(r, KErrNotFound);

   682 	// Transaction state should be ENoTransaction due to call to RollbackTransaction()

   683 	r = TransactionState(repository);

   684 	TEST2(r, ENoTransaction);

   686 	// Begin read transaction

   687 	r = repository->StartTransaction(CRepository::EReadTransaction);

   688 	TEST2(r, KErrNone);

   690 	r = TransactionState(repository);

   691 	TEST2(r, EReadTransaction);

   693 	r = repository->Get(KReal1, getValue);

   694 	TEST2(r, KErrNone);

   695 	TEST(getValue == KReal1_InitialValue);

   697 	// Fail transaction

   698 	repository->FailTransaction();

   700 	r = TransactionState(repository);

   701 	TEST2(r, EReadTransaction | EFailedBit);

   703 	// Commit transaction

   704 	r = repository->CommitTransaction(errorId);

   705 	TEST2(r, KErrAbort);

   707 	r = TransactionState(repository);

   708 	TEST2(r, ENoTransaction);

   710 	// Begin another read transaction

   711 	r = repository->StartTransaction(CRepository::EReadTransaction);

   712 	TEST2(r, KErrNone);

   714 	r = repository->Get(KReal1, getValue);

   715 	TEST2(r, KErrNone);

   716 	TEST(getValue == KReal1_InitialValue);

   718 	r = TransactionState(repository);

   719 	TEST2(r, EReadTransaction);

   721 	// Perform Create in a ReadTransaction as upgrade has occured

   722 	r = repository->Create(KReal2, KReal2_InitialValue);

   723 	TEST2(r, KErrNone);

   725 	// The state should be updated to be EInReadWriteTransaction

   726 	r = TransactionState(repository);

   727 	TEST2(r, EReadWriteTransaction);

   729 	r = repository->Get(KReal2, getValue);

   730 	TEST2(r, KErrNone);

   732 	// Commit transaction

   733 	r = repository->CommitTransaction(errorId);

   734 	TEST2(r, KErrNone);

   736 	// Delete KReal2 to reset available test case variables

   737 	r = repository->Delete(KReal2);

   738 	TEST2(r, KErrNone);

   740 	r = TransactionState(repository);

   741 	TEST2(r, ENoTransaction);

   743 	CleanupStack::PopAndDestroy(repository);

   744 	}

   746 LOCAL_C void StartTransactionPanicConditionsL()

   747 	{

   748 	TInt r;

   749 	TUint32 errorId;

   751 	CRepository* repository1;

   753 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

   755 	// Begin read write transaction

   756 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

   757 	TEST2(r, KErrNone);

   759 	// This should panic can't start second transaction in one session

   760 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

   761 	TEST2(r, KErrNone);

   763 	// Commit transaction

   764 	r = repository1->CommitTransaction(errorId);

   765 	TEST2(r, KErrNone);

   767 	CleanupStack::PopAndDestroy(repository1);

   768 	}

   770 LOCAL_C TInt TestStartTransactionPanics(TAny* /*aData*/)

   771 	{

   772 	__UHEAP_MARK;

   773 	CTrapCleanup* cleanup = CTrapCleanup::New();

   774 	if(!cleanup)

   775 		return KErrNoMemory;

   777 	TRAPD(err, StartTransactionPanicConditionsL());

   779 	// Won't get here but add this line to get rid of ARMV5 warning

   780 	TEST2(err, KErrNone);

   782 	delete cleanup;

   783 	__UHEAP_MARKEND;

   785 	return (KErrNone);

   786 	}

   788 /**

   789 @SYMTestCaseID SYSLIB-CENREP-CT-0154

   790 @SYMTestCaseDesc Testing valid panics while using StartTransaction

   791 @SYMTestPriority High

   792 @SYMTestActions  Start a separate thread and within that thread try to start transaction twice

   793 @SYMTestExpectedResults The thread should exit with the exit type EExitPanic and exit reason EStartAlreadyInTransaction

   794 @SYMPREQ PREQ752

   795 */

   796 LOCAL_C void TransactionPanicConditionsThread()

   797 	{

   798 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0154 "));

   799 	TBool jitEnabled = User::JustInTime();

   800 	User::SetJustInTime(EFalse);

   802 	TRequestStatus status;

   804 	_LIT(KName, "Transaction_Panic_Thread");

   806 	RThread thread;

   807 	TInt rc = thread.Create(KName,TestStartTransactionPanics,KThreadStackSize,KThreadMinHeapSize,KThreadMaxHeapSize,NULL);

   809 	TEST2(rc,KErrNone);

   811 	thread.Logon(status);

   812 	thread.Resume();

   814 	User::WaitForRequest(status);

   816 	// Should result in a EExitPanic exit type and an EStartAlreadyInTransaction exit reason

   817 	TEST2(thread.ExitType(), EExitPanic);

   818 	TEST2(thread.ExitReason(), EStartAlreadyInTransaction);

   820 	thread.Close();

   822 	User::SetJustInTime(jitEnabled);

   823 	}

   825 LOCAL_C void CommitTransactionPanicConditionL()

   826 	{

   827 	TInt r;

   828 	TUint32 errorId;

   830 	CRepository* repository1;

   832 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

   834 	// Commit transaction when there is not transaction should cause a panic

   835 	r = repository1->CommitTransaction(errorId);

   836 	TEST2(r, KErrNone);

   838 	CleanupStack::PopAndDestroy(repository1);

   839 	}

   842 LOCAL_C TInt TestCommitTransactionPanics(TAny* /*aData*/)

   843 	{

   844 	__UHEAP_MARK;

   845 	CTrapCleanup* cleanup = CTrapCleanup::New();

   846 	if(!cleanup)

   847 		return KErrNoMemory;

   849 	TRAPD(err,CommitTransactionPanicConditionL());

   851 	// Won't get here but add this line to get rid of ARMV5 warning

   852 	TEST2(err, KErrNone);

   854 	delete cleanup;

   855 	__UHEAP_MARKEND;

   856 	return (KErrNone);

   857 	}

   859 /**

   860 @SYMTestCaseID SYSLIB-CENREP-CT-0155

   861 @SYMTestCaseDesc Testing valid panics while using CommitTransaction

   862 @SYMTestPriority High

   863 @SYMTestActions  Start a separate thread and within that thread try to commit a transaction without being in one

   864 @SYMTestExpectedResults The thread should exit with the exit type EExitPanic and the exit reason ECommitNotInTransaction

   865 @SYMPREQ PREQ752

   866 */

   867 LOCAL_C void CommitTransactionPanicConditionsThread()

   868 	{

   869 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0155 "));

   870 	TBool jitEnabled = User::JustInTime();

   871 	User::SetJustInTime(EFalse);

   873 	TRequestStatus status;

   875 	_LIT(KName, "Commit_Transaction_Panic_Thread");

   877 	RThread thread;

   878 	TInt rc = thread.Create(KName,TestCommitTransactionPanics,KThreadStackSize,KThreadMinHeapSize,KThreadMaxHeapSize,NULL);

   880 	TEST2(rc,KErrNone);

   882 	thread.Logon(status);

   883 	thread.Resume();

   885 	User::WaitForRequest(status);

   887 	// Should result in a EExitPanic exit type and an ECommitNotInTransaction exit reason

   888 	TEST2(thread.ExitType(), EExitPanic);

   889 	TEST2(thread.ExitReason(), ECommitNotInTransaction);

   891 	thread.Close();

   893 	User::SetJustInTime(jitEnabled);

   894 	}

   896 LOCAL_C void LeaveWithCleanupRollbackTransactionPushL(CRepository& aRepository)

   897 	{

   898 	TInt r = TransactionState(&aRepository);

   899 	TEST2(r, CRepository::EReadWriteTransaction);

   901 	aRepository.CleanupRollbackTransactionPushL();

   903 	// Purposely leave in a transaction...

   904 	User::LeaveNoMemory();

   906 	// this code should never be reached...

   907 	TEST(EFalse);

   908 	// ...but if it did we'd have to cleanup the PushL

   909 	CleanupStack::Pop();

   910 	}

   912 LOCAL_C void LeaveWithCleanupFailTransactionPushL(CRepository& aRepository)

   913 	{

   914 	TInt r = TransactionState(&aRepository);

   915 	TEST2(r, CRepository::EReadWriteTransaction);

   917 	aRepository.CleanupFailTransactionPushL();

   919 	// Purposely leave in a transaction...

   920 	User::LeaveNoMemory();

   922 	// this code should never be reached...

   923 	TEST(EFalse);

   924 	// ...but if it did we'd have to cleanup the PushL

   925 	CleanupStack::Pop();

   926 	}

   928 /**

   929 @SYMTestCaseID SYSLIB-CENREP-CT-0156

   930 @SYMTestCaseDesc Testing CleanupRollbackTransactionPushL and CleanupFailTransactionPushL

   931 @SYMTestPriority High

   932 @SYMTestActions Start a transaction and use CleanupRollbackTransactionPushL. Within the transaction purposely leave, as this will

   933 	result in CleanupRollbackTransactionPushL being used. Similar operation required for CleanupFailTransactionPushL

   934 @SYMTestExpectedResults The test should not fail with any panics

   935 @SYMPREQ PREQ752

   936 */

   937 LOCAL_C void CleanupRollBackAndFailTransactionL()

   938 	{

   939 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0156 "));

   940 	TInt r;

   941 	TUint32 errorId;

   942 	TReal getValue;

   944 	CRepository* repository;

   946 	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository));

   948 	r = repository->StartTransaction(CRepository::EReadWriteTransaction);

   949 	TEST2(r, KErrNone);

   951 	repository->CleanupRollbackTransactionPushL();

   953 	r = repository->Create(KReal2, KReal2_InitialValue);

   954 	TEST2(r, KErrNone);

   956 	// Purposely leave in a transaction...

   957 	TRAP(r, LeaveWithCleanupRollbackTransactionPushL(*repository));

   958 	TEST2(r, KErrNoMemory);

   960 	// should cause RollbackTransaction, therefore transaction state should be ENoTransaction...

   962 	r = TransactionState(repository);

   963 	TEST2(r, ENoTransaction);

   965 	// and getting the value KReal2 should result in KErrNotFound

   966 	r = repository->Get(KReal2, getValue);

   967 	TEST2(r, KErrNotFound);

   969 	CleanupStack::Pop();				// CleanupRollbackTransaction

   971 	r = repository->StartTransaction(CRepository::EReadWriteTransaction);

   972 	TEST2(r, KErrNone);

   974 	repository->CleanupFailTransactionPushL();

   976 	r = repository->Create(KReal2, KReal2_InitialValue);

   977 	TEST2(r, KErrNone);

   979 	// Purposely leave in a transaction...

   980 	TRAP(r, LeaveWithCleanupFailTransactionPushL(*repository));

   981 	TEST2(r, KErrNoMemory);

   983 	// should cause FailTransaction, therefore transaction state should be EInFailedReadWriteTransaction...

   984 	r = TransactionState(repository);

   985 	TEST2(r, EReadWriteTransaction | EFailedBit);

   987 	// only after commit will Fail Transaction call roll back...

   988 	r = repository->CommitTransaction(errorId);

   989 	TEST2(r, KErrAbort);

   991 	// so getting the value KReal2 should result in KErrNotFound

   992 	r = repository->Get(KReal2, getValue);

   993 	TEST2(r, KErrNotFound);

   995 	r = TransactionState(repository);

   996 	TEST2(r, ENoTransaction);

   998 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1000 	CleanupStack::PopAndDestroy(repository);

  1001 	}

  1003 /**

  1004 @SYMTestCaseID SYSLIB-CENREP-CT-0157

  1005 @SYMTestCaseDesc Test Read Transaction Conditions

  1006 @SYMTestPriority High

  1007 @SYMTestActions Start read transactions and perform read operations

  1008 @SYMTestExpectedResults The test should not fail with any panics

  1009 @SYMPREQ PREQ752

  1010 */

  1011 LOCAL_C void ReadTransactionConditionsL()

  1012 	{

  1013 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0157 "));

  1014 	TInt r;

  1015 	TUint32 errorId;

  1016 	TInt intVal;

  1018 	CRepository* repository1;

  1019 	CRepository* repository2;

  1020 	CRepository* repository3;

  1022 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1023 	User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));

  1024 	User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository));

  1026 	// Begin transaction for repository1

  1027 	r = repository1->StartTransaction(CRepository::EReadTransaction);

  1028 	TEST2(r, KErrNone);

  1030 	// Should be able to start another read transaction

  1031 	r = repository2->StartTransaction(CRepository::EReadTransaction);

  1032 	TEST2(r, KErrNone);

  1034 	// Perform some gets using the open transactions and repository

  1035 	r = repository1->Get(KInt1, intVal);

  1036 	TEST2(r, KErrNone);

  1037 	TEST2(intVal, KInt1_InitialValue);

  1039 	r = repository2->Get(KInt1, intVal);

  1040 	TEST2(r, KErrNone);

  1041 	TEST2(intVal, KInt1_InitialValue);

  1043 	r = repository3->Get(KInt1, intVal);

  1044 	TEST2(r, KErrNone);

  1045 	TEST2(intVal, KInt1_InitialValue);

  1047 	// Get the state of Transactions

  1048 	r = TransactionState(repository1);

  1049 	TEST2(r, EReadTransaction);

  1051 	r = TransactionState(repository1);

  1052 	TEST2(r, EReadTransaction);

  1054 	r = repository1->CommitTransaction(errorId);

  1055 	TEST2(r, KErrNone);

  1056 	// Test for the value of errorId for a successful read transaction: no changes

  1057 	TEST2(errorId, 0);

  1059 	r = repository2->CommitTransaction(errorId);

  1060 	TEST2(r, KErrNone);

  1061 	// Test for the value of errorId for a successful read transaction: no changes

  1062 	TEST2(errorId, 0);

  1064 	CleanupStack::PopAndDestroy(repository3);

  1065 	CleanupStack::PopAndDestroy(repository2);

  1066 	CleanupStack::PopAndDestroy(repository1);

  1067 	}

  1069 /**

  1070 @SYMTestCaseID SYSLIB-CENREP-CT-0158

  1071 @SYMTestCaseDesc Test upgrade read transaction with error conditions

  1072 @SYMTestPriority High

  1073 @SYMTestActions Start read transactions and try to upgrade one of the read transactions

  1074 @SYMTestExpectedResults The test should not fail with any panics

  1075 @SYMPREQ PREQ752

  1076 */

  1077 LOCAL_C void UpgradeReadTransactionErrorConditionsL()

  1078 	{

  1079 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0158 "));

  1080 	TInt r;

  1081 	TUint32 errorId;

  1082 	TInt intVal;

  1084 	CRepository* repository1;

  1085 	CRepository* repository2;

  1086 	CRepository* repository3;

  1088 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1089 	User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));

  1090 	User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository));

  1092 	// Begin transaction for repository1

  1093 	r = repository1->StartTransaction(CRepository::EReadTransaction);

  1094 	TEST2(r, KErrNone);

  1096 	// Should be able to start another read transaction

  1097 	r = repository2->StartTransaction(CRepository::EReadTransaction);

  1098 	TEST2(r, KErrNone);

  1100 	// Perform get using open transaction

  1101 	r = repository2->Get(KInt1, intVal);

  1102 	TEST2(r, KErrNone);

  1103 	TEST2(intVal, KInt1_InitialValue);

  1105 	// Perform create which should fail transaction with KErrLocked

  1106 	r = repository1->Create(KInt2, KInt2_InitialValue);

  1107 	TEST2(r, KErrLocked);

  1109 	// check the value is not there as far as repository 3 is concerned

  1110 	r = repository3->Get(KInt2, intVal);

  1111 	TEST2(r, KErrNotFound);

  1113 	// Get the state of Transactions

  1114 	r = TransactionState(repository1);

  1115 	TEST2(r, EReadTransaction | EFailedBit);

  1117 	r = TransactionState(repository2);

  1118 	TEST2(r, EReadTransaction);

  1120 	r = repository2->CommitTransaction(errorId);

  1121 	TEST2(r, KErrNone);

  1123 	r = repository1->CommitTransaction(errorId);

  1124 	TEST2(r, KErrLocked);

  1125 	// Check the key responsible for the failed read transaction promote

  1126 	TEST2(errorId, KInt2);

  1128 	CleanupStack::PopAndDestroy(repository3);

  1129 	CleanupStack::PopAndDestroy(repository2);

  1130 	CleanupStack::PopAndDestroy(repository1);

  1131 	}

  1133 /**

  1134 @SYMTestCaseID SYSLIB-CENREP-CT-0159

  1135 @SYMTestCaseDesc Test read operations with a read write transaction open

  1136 @SYMTestPriority High

  1137 @SYMTestActions Start a transaction and try to perform some read operations outside of the open transaction

  1138 @SYMTestExpectedResults The test should not fail with any panics

  1139 @SYMPREQ PREQ752

  1140 */

  1141 LOCAL_C void TransactionConditionsForReadL()

  1142 	{

  1143 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0159 "));

  1144 	TInt r;

  1145 	TUint32 errorId;

  1146 	RArray<TUint32> foundIds;

  1148 	CRepository* repository1;

  1149 	CRepository* repository2;

  1151 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1152 	User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));

  1154 	// Begin transaction for repository1

  1155 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1156 	TEST2(r, KErrNone);

  1158 	r = TransactionState(repository1);

  1159 	TEST2(r, EReadWriteTransaction);

  1161 	// Should be able to get values regardless of transaction1 being open

  1162 	TInt intVal;

  1163 	r = repository2->Get(KInt1, intVal);

  1164 	TEST2(r, KErrNone);

  1165 	TEST2(intVal, KInt1_InitialValue);

  1167 	TReal realVal;

  1168 	r = repository2->Get(KReal1, realVal);

  1169 	TEST2(r, KErrNone);

  1170 	TEST(realVal==KReal1_InitialValue);

  1172 	TBuf8<14> buf8Val;

  1173 	r = repository2->Get(KString8, buf8Val);

  1174 	TEST2(r, KErrNone);

  1175 	TEST(buf8Val==KString8_InitialValue);

  1177 	TBuf16<14> buf16Val;

  1178 	r = repository2->Get(KString16, buf16Val);

  1179 	TEST2(r, KErrNone);

  1180 	TEST(buf16Val==KString16_InitialValue);

  1182 	r = repository2->FindL(0, KUnprotectedSettingsMask, foundIds);

  1183 	TEST2(r, KErrNone);

  1184 	TEST(foundIds.Count()==4);

  1186 	foundIds.Reset();

  1188 	// Find in range for values equal to KInt1_InitialValue

  1189 	r = repository2->FindEqL(0, KUnprotectedSettingsMask, KInt1_InitialValue, foundIds);

  1190 	TEST2(r, KErrNone);

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

  1193 	foundIds.Reset();

  1195 	// Find in range for values NOT equal to KInt1_InitialValue

  1196 	r = repository2->FindNeqL(0, KUnprotectedSettingsMask, KInt1_InitialValue, foundIds);

  1197 	TEST2(r, KErrNone);

  1198 	TEST(foundIds.Count()==3);

  1200 	foundIds.Reset();

  1202 	// Find in range for values equal to KReal1_InitialValue

  1203 	r = repository2->FindEqL(0, KUnprotectedSettingsMask, KReal1_InitialValue, foundIds);

  1204 	TEST2(r, KErrNone);

  1205 	TEST2(foundIds.Count(),1);

  1207 	foundIds.Reset();

  1209 	// Find in range for values NOT equal to KReal1_InitialValue

  1210 	r = repository2->FindNeqL(0, KUnprotectedSettingsMask, KReal1_InitialValue, foundIds);

  1211 	TEST2(r, KErrNone);

  1212 	TEST2(foundIds.Count(),3);

  1214 	// Find in range for values equal to KString8_InitialValue

  1215 	r = repository2->FindEqL(0, KUnprotectedSettingsMask, KString8_InitialValue, foundIds);

  1216 	TEST2(r, KErrNone);

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

  1219 	foundIds.Reset();

  1221 	// Find in range for values NOT equal to KString8_InitialValue

  1222 	r = repository2->FindNeqL(0, KUnprotectedSettingsMask, KString8_InitialValue, foundIds);

  1223 	TEST2(r, KErrNone);

  1224 	TEST2(foundIds.Count(),3);

  1227 	// Find in range for values equal to KString16_InitialValue

  1228 	r = repository2->FindEqL(0, KUnprotectedSettingsMask, KString16_InitialValue, foundIds);

  1229 	TEST2(r, KErrNone);

  1230 	TEST2(foundIds.Count(),1);

  1232 	foundIds.Reset();

  1234 	// Find in range for values NOT equal to KString16_InitialValue

  1235 	r = repository2->FindNeqL(0, KUnprotectedSettingsMask, KString16_InitialValue, foundIds);

  1236 	TEST2(r, KErrNone);

  1237 	TEST2(foundIds.Count(),3);

  1239 	foundIds.Reset();

  1241 	r = repository1->CommitTransaction(errorId);

  1242 	TEST2(r, KErrNone);

  1244 	CleanupStack::PopAndDestroy(repository2);

  1245 	CleanupStack::PopAndDestroy(repository1);

  1246 	}

  1248 /**

  1249 @SYMTestCaseID SYSLIB-CENREP-CT-0160

  1250 @SYMTestCaseDesc Test Transaction error conditions with get

  1251 @SYMTestPriority High

  1252 @SYMTestActions Start a transaction and perform some problematic gets. Test to see if it fails transactions or not.

  1253 @SYMTestExpectedResults The test should not fail with any panics

  1254 @SYMPREQ PREQ752

  1255 */

  1256 LOCAL_C void TransactionErrorConditionsForGetL()

  1257 	{

  1258 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0160 "));

  1259 	TInt r;

  1260 	TUint32 errorId;

  1262 	CRepository* repository1;

  1264 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1266 	// Begin transaction for repository1

  1267 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1268 	TEST2(r, KErrNone);

  1270 	// Should NOT fail transaction

  1271 	TInt intVal;

  1272 	r = repository1->Get(KInt2, intVal);

  1273 	TEST2(r, KErrNotFound);

  1275 	r = TransactionState(repository1);

  1276 	TEST2(r, EReadWriteTransaction);

  1278 	// Should NOT fail transaction

  1279 	TReal realVal;

  1280 	r = repository1->Get(KInt1, realVal);

  1281 	TEST2(r, KErrArgument);

  1283 	r = TransactionState(repository1);

  1284 	TEST2(r, EReadWriteTransaction);

  1286 	// Should NOT fail transaction

  1287 	r = repository1->Get(KReal2, realVal);

  1288 	TEST2(r, KErrNotFound);

  1290 	r = TransactionState(repository1);

  1291 	TEST2(r, EReadWriteTransaction);

  1293 	// Should NOT fail transaction

  1294 	r = repository1->Get(KReal1, intVal);

  1295 	TEST2(r, KErrArgument);

  1297 	r = TransactionState(repository1);

  1298 	TEST2(r, EReadWriteTransaction);

  1300 	// Should NOT fail transaction

  1301 	TBuf8<14> buf8Val;

  1302 	r = repository1->Get(KNewString8, buf8Val);

  1303 	TEST2(r, KErrNotFound);

  1305 	r = TransactionState(repository1);

  1306 	TEST2(r, EReadWriteTransaction);

  1308 	// Should NOT fail transaction

  1309 	r = repository1->Get(KString8, intVal);

  1310 	TEST2(r, KErrArgument);

  1312 	r = TransactionState(repository1);

  1313 	TEST2(r, EReadWriteTransaction);

  1315 	// Should NOT fail transaction

  1316 	TBuf8<2> smallBuf8Val;

  1317 	r = repository1->Get(KString8, smallBuf8Val);

  1318 	TEST2(r, KErrOverflow);

  1319 	TEST(smallBuf8Val==KString8_Small_Value);

  1321 	r = TransactionState(repository1);

  1322 	TEST2(r, EReadWriteTransaction);

  1324 	// Should NOT fail transaction

  1325 	TBuf16<14> buf16Val;

  1326 	r = repository1->Get(KNewString16, buf16Val);

  1327 	TEST2(r, KErrNotFound);

  1329 	r = TransactionState(repository1);

  1330 	TEST2(r, EReadWriteTransaction);

  1332 	// Should NOT fail transaction

  1333 	r = repository1->Get(KString16, intVal);

  1334 	TEST2(r, KErrArgument);

  1336 	r = TransactionState(repository1);

  1337 	TEST2(r, EReadWriteTransaction);

  1339 	// Should NOT fail transaction

  1340 	TBuf16<2> smallBuf16Val;

  1341 	r = repository1->Get(KString16, smallBuf16Val);

  1342 	TEST2(r, KErrOverflow);

  1343 	TEST(smallBuf16Val==KString16_Small_Value);

  1345 	r = TransactionState(repository1);

  1346 	TEST2(r, EReadWriteTransaction);

  1348 	r = repository1->CommitTransaction(errorId);

  1349 	TEST2(r, KErrNone);

  1351 	r = TransactionState(repository1);

  1352 	TEST2(r, ENoTransaction);

  1354 	CleanupStack::PopAndDestroy(repository1);

  1355 	}

  1357 /**

  1358 @SYMTestCaseID SYSLIB-CENREP-CT-0161

  1359 @SYMTestCaseDesc Test Transaction error conditions with find

  1360 @SYMTestPriority High

  1361 @SYMTestActions Start a transaction and perform some problematic find operations. Test to see if it fails transactions or not.

  1362 @SYMTestExpectedResults The test should not fail with any panics

  1363 @SYMPREQ PREQ752

  1364 */

  1365 LOCAL_C void TransactionErrorConditionsForFindL()

  1366 	{

  1367 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0161 "));

  1368 	TInt r;

  1369 	TUint32 errorId;

  1370 	RArray<TUint32> foundIds;

  1372 	CRepository* repository1;

  1374 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1376 	// Begin transaction for repository1

  1377 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1378 	TEST2(r, KErrNone);

  1380 	repository1->CleanupRollbackTransactionPushL();

  1382 	// Should NOT fail transaction

  1383 	r = repository1->FindL(100, 110, foundIds);

  1384 	TEST2(r, KErrNotFound);

  1386 	foundIds.Reset();

  1388 	r = TransactionState(repository1);

  1389 	TEST2(r, EReadWriteTransaction);

  1391 	r = repository1->CommitTransaction(errorId);

  1392 	TEST2(r, KErrNone);

  1394 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1396 	r = TransactionState(repository1);

  1397 	TEST2(r, ENoTransaction);

  1399 	CleanupStack::PopAndDestroy(repository1);

  1400 	}

  1402 /**

  1403 @SYMTestCaseID SYSLIB-CENREP-CT-0162

  1404 @SYMTestCaseDesc Test Transaction error conditions with findeq

  1405 @SYMTestPriority High

  1406 @SYMTestActions Start a transaction and perform some problematic findeq operations. Test to see if it fails transactions or not.

  1407 @SYMTestExpectedResults The test should not fail with any panics

  1408 @SYMPREQ PREQ752

  1409 */

  1410 LOCAL_C void TransactionErrorConditionsForFindEqL()

  1411 	{

  1412 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0162 "));

  1413 	TInt r;

  1414 	TUint32 errorId;

  1415 	RArray<TUint32> foundIds;

  1417 	CRepository* repository1;

  1419 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1421 	// Begin transaction for repository1

  1422 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1423 	TEST2(r, KErrNone);

  1425 	repository1->CleanupRollbackTransactionPushL();

  1427 	// Should NOT fail transaction

  1428 	r = repository1->FindEqL(0, KUnprotectedSettingsMask, KInt2_InitialValue, foundIds);

  1429 	TEST2(r, KErrNotFound);

  1431 	foundIds.Reset();

  1433 	r = TransactionState(repository1);

  1434 	TEST2(r, EReadWriteTransaction);

  1436 	r = repository1->CommitTransaction(errorId);

  1437 	TEST2(r, KErrNone);

  1439 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1441 	r = TransactionState(repository1);

  1442 	TEST2(r, ENoTransaction);

  1444 	// Begin transaction for repository1

  1445 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1446 	TEST2(r, KErrNone);

  1448 	repository1->CleanupRollbackTransactionPushL();

  1450 	// Should NOT fail transaction

  1451 	r = repository1->FindEqL(0, KUnprotectedSettingsMask, KReal2_InitialValue, foundIds);

  1452 	TEST2(r, KErrNotFound);

  1454 	foundIds.Reset();

  1456 	r = TransactionState(repository1);

  1457 	TEST2(r, EReadWriteTransaction);

  1459 	r = repository1->CommitTransaction(errorId);

  1460 	TEST2(r, KErrNone);

  1462 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1464 	r = TransactionState(repository1);

  1465 	TEST2(r, ENoTransaction);

  1467 	// Begin transaction for repository1

  1468 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1469 	TEST2(r, KErrNone);

  1471 	repository1->CleanupRollbackTransactionPushL();

  1473 	// Should NOT fail transaction

  1474 	r = repository1->FindEqL(0, KUnprotectedSettingsMask, KString8_InitialValue2, foundIds);

  1475 	TEST2(r, KErrNotFound);

  1477 	foundIds.Reset();

  1479 	r = TransactionState(repository1);

  1480 	TEST2(r, EReadWriteTransaction);

  1482 	r = repository1->CommitTransaction(errorId);

  1483 	TEST2(r, KErrNone);

  1485 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1487 	r = TransactionState(repository1);

  1488 	TEST2(r, ENoTransaction);

  1490 	// Begin transaction for repository1

  1491 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1492 	TEST2(r, KErrNone);

  1494 	repository1->CleanupRollbackTransactionPushL();

  1496 	// Should NOT fail transaction

  1497 	r = repository1->FindEqL(0, KUnprotectedSettingsMask, KString16_InitialValue2, foundIds);

  1498 	TEST2(r, KErrNotFound);

  1500 	foundIds.Reset();

  1502 	r = TransactionState(repository1);

  1503 	TEST2(r, EReadWriteTransaction);

  1505 	r = repository1->CommitTransaction(errorId);

  1506 	TEST2(r, KErrNone);

  1508 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1510 	r = TransactionState(repository1);

  1511 	TEST2(r, ENoTransaction);

  1513 	CleanupStack::PopAndDestroy(repository1);

  1514 	}

  1516 /**

  1517 @SYMTestCaseID SYSLIB-CENREP-CT-0163

  1518 @SYMTestCaseDesc Test Transaction error conditions with findneq

  1519 @SYMTestPriority High

  1520 @SYMTestActions Start a transaction and perform some problematic findneq operations. Test to see if it fails transactions or not.

  1521 @SYMTestExpectedResults The test should not fail with any panics

  1522 @SYMPREQ PREQ752

  1523 */

  1524 LOCAL_C void TransactionErrorConditionsForFindNeqL()

  1525 	{

  1526 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0163 "));

  1527 	TInt r;

  1528 	TUint32 errorId;

  1529 	RArray<TUint32> foundIds;

  1531 	CRepository* repository1;

  1533 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1535 	// Begin transaction for repository1

  1536 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1537 	TEST2(r, KErrNone);

  1539 	repository1->CleanupRollbackTransactionPushL();

  1541 	// Should NOT fail transaction

  1542 	r = repository1->FindNeqL(100, 110, KInt1_InitialValue, foundIds);

  1543 	TEST2(r, KErrNotFound);

  1545 	foundIds.Reset();

  1547 	r = TransactionState(repository1);

  1548 	TEST2(r, EReadWriteTransaction);

  1550 	r = repository1->CommitTransaction(errorId);

  1551 	TEST2(r, KErrNone);

  1553 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1555 	r = TransactionState(repository1);

  1556 	TEST2(r, ENoTransaction);

  1558 	// Begin transaction for repository1

  1559 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1560 	TEST2(r, KErrNone);

  1562 	repository1->CleanupRollbackTransactionPushL();

  1564 	// Should NOT fail transaction

  1565 	r = repository1->FindNeqL(100, 110, KReal1_InitialValue, foundIds);

  1566 	TEST2(r, KErrNotFound);

  1568 	foundIds.Reset();

  1570 	r = TransactionState(repository1);

  1571 	TEST2(r, EReadWriteTransaction);

  1573 	r = repository1->CommitTransaction(errorId);

  1574 	TEST2(r, KErrNone);

  1576 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1578 	r = TransactionState(repository1);

  1579 	TEST2(r, ENoTransaction);

  1581 	// Begin transaction for repository1

  1582 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1583 	TEST2(r, KErrNone);

  1585 	repository1->CleanupRollbackTransactionPushL();

  1587 	// Should NOT fail transaction

  1588 	r = repository1->FindNeqL(100, 110, KString8_InitialValue, foundIds);

  1589 	TEST2(r, KErrNotFound);

  1591 	foundIds.Reset();

  1593 	r = TransactionState(repository1);

  1594 	TEST2(r, EReadWriteTransaction);

  1596 	r = repository1->CommitTransaction(errorId);

  1597 	TEST2(r, KErrNone);

  1599 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1601 	r = TransactionState(repository1);

  1602 	TEST2(r, ENoTransaction);

  1604 	// Begin transaction for repository1

  1605 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1606 	TEST2(r, KErrNone);

  1608 	repository1->CleanupRollbackTransactionPushL();

  1610 	// Should NOT fail transaction

  1611 	r = repository1->FindNeqL(100, 110, KString16_InitialValue, foundIds);

  1612 	TEST2(r, KErrNotFound);

  1614 	foundIds.Reset();

  1616 	r = TransactionState(repository1);

  1617 	TEST2(r, EReadWriteTransaction);

  1619 	r = repository1->CommitTransaction(errorId);

  1620 	TEST2(r, KErrNone);

  1622 	CleanupStack::Pop();				// CleanupRollbackTransaction

  1624 	r = TransactionState(repository1);

  1625 	TEST2(r, ENoTransaction);

  1627 	CleanupStack::PopAndDestroy(repository1);

  1628 	}

  1630 /**

  1631 @SYMTestCaseID SYSLIB-CENREP-CT-0164

  1632 @SYMTestCaseDesc Test Transaction error conditions with create

  1633 @SYMTestPriority High

  1634 @SYMTestActions Start a transaction and perform some problematic create operations. Test to see if it fails transactions or not.

  1635 @SYMTestExpectedResults The test should not fail with any panics

  1636 @SYMPREQ PREQ752

  1637 */

  1638 LOCAL_C void TransactionErrorConditionsForCreateL()

  1639 	{

  1640 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0164 "));

  1641 	TInt r;

  1642 	TUint32 errorId;

  1644 	CRepository* repository1;

  1646 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1648 	// Begin transaction for repository1

  1649 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1650 	TEST2(r, KErrNone);

  1652 	// Should fail the transaction

  1653 	r = repository1->Create(KInt1, KInt1_InitialValue);

  1654 	TEST2(r, KErrAlreadyExists);

  1656 	r = TransactionState(repository1);

  1657 	TEST2(r, EReadWriteTransaction | EFailedBit);

  1659 	r = repository1->CommitTransaction(errorId);

  1660 	TEST2(r, KErrAlreadyExists);

  1661 	TEST2(errorId, KInt1);

  1663 	r = TransactionState(repository1);

  1664 	TEST2(r, ENoTransaction);

  1666 	// Begin transaction for repository1

  1667 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1668 	TEST2(r, KErrNone);

  1670 	// Should fail the transaction

  1671 	r = repository1->Create(KReal1, KReal1_InitialValue);

  1672 	TEST2(r, KErrAlreadyExists);

  1674 	r = TransactionState(repository1);

  1675 	TEST2(r, EReadWriteTransaction | EFailedBit);

  1677 	r = repository1->CommitTransaction(errorId);

  1678 	TEST2(r, KErrAlreadyExists);

  1679 	TEST2(errorId, KReal1);

  1681 	r = TransactionState(repository1);

  1682 	TEST2(r, ENoTransaction);

  1684 	// Begin transaction for repository1

  1685 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1686 	TEST2(r, KErrNone);

  1688 	// Should fail the transaction

  1689 	r = repository1->Create(KString8, KString8_InitialValue);

  1690 	TEST2(r, KErrAlreadyExists);

  1692 	r = TransactionState(repository1);

  1693 	TEST2(r, EReadWriteTransaction | EFailedBit);

  1695 	r = repository1->CommitTransaction(errorId);

  1696 	TEST2(r, KErrAlreadyExists);

  1697 	TEST2(errorId, KString8);

  1699 	r = TransactionState(repository1);

  1700 	TEST2(r, ENoTransaction);

  1702 	// Begin transaction for repository1

  1703 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1704 	TEST2(r, KErrNone);

  1706 	// Should fail the transaction

  1707 	r = repository1->Create(KString16, KString16_InitialValue);

  1708 	TEST2(r, KErrAlreadyExists);

  1710 	r = TransactionState(repository1);

  1711 	TEST2(r, EReadWriteTransaction | EFailedBit);

  1713 	r = repository1->CommitTransaction(errorId);

  1714 	TEST2(r, KErrAlreadyExists);

  1715 	TEST2(errorId, KString16);

  1717 	r = TransactionState(repository1);

  1718 	TEST2(r, ENoTransaction);

  1720 	CleanupStack::PopAndDestroy(repository1);

  1721 	}

  1723 /**

  1724 @SYMTestCaseID SYSLIB-CENREP-CT-0165

  1725 @SYMTestCaseDesc Test Transaction error conditions with delete

  1726 @SYMTestPriority High

  1727 @SYMTestActions Start a transaction and perform some problematic delete operations. Test to see if it fails transactions or not.

  1728 @SYMTestExpectedResults The test should not fail with any panics

  1729 @SYMPREQ PREQ752

  1730 */

  1731 LOCAL_C void TransactionErrorConditionsForDeleteL()

  1732 	{

  1733 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0165 "));

  1734 	TInt r;

  1735 	TUint32 errorId;

  1737 	CRepository* repository1;

  1739 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1741 	// Begin transaction for repository1

  1742 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1743 	TEST2(r, KErrNone);

  1745 	// Delete KInt2 which does not exist

  1746 	r = repository1->Delete(KInt2);

  1747 	TEST2(r, KErrNotFound);

  1749 	r = TransactionState(repository1);

  1750 	TEST2(r, EReadWriteTransaction);

  1752 	r = repository1->CommitTransaction(errorId);

  1753 	TEST2(r, KErrNone);

  1755 	r = TransactionState(repository1);

  1756 	TEST2(r, ENoTransaction);

  1758 	CleanupStack::PopAndDestroy(repository1);

  1759 	}

  1761 /**

  1762 @SYMTestCaseID SYSLIB-CENREP-CT-0166

  1763 @SYMTestCaseDesc Test Transaction error conditions with set

  1764 @SYMTestPriority High

  1765 @SYMTestActions Start a transaction and perform some problematic set operations. Test to see if it fails transactions or not.

  1766 @SYMTestExpectedResults The test should not fail with any panics

  1767 @SYMPREQ PREQ752

  1768 */

  1769 LOCAL_C void TransactionErrorConditionsForSetL()

  1770 	{

  1771 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0166 "));

  1772 	TInt r;

  1773 	TUint32 errorId;

  1774     TInt i;

  1776 	CRepository* repository1;

  1778 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1780 	// Begin transaction for repository1

  1781 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1782 	TEST2(r, KErrNone);

  1784 	r = repository1->Get(KInt2, i);

  1785 	TEST2(r, KErrNotFound);

  1787 	// Set KInt2 which does not exist

  1788 	r = repository1->Set(KInt2, KInt2_InitialValue);

  1789 	TEST2(r, KErrNone);

  1791 	r = repository1->Get(KInt2, i);

  1792 	TEST2(r, KErrNone);

  1793     TEST2(i, KInt2_InitialValue);

  1795     // Set KInt2 to a value of real type

  1796     r = repository1->Set(KInt2, KReal2_InitialValue);

  1797     TEST2(r, KErrArgument);

  1799 	r = TransactionState(repository1);

  1800 	TEST2(r, EReadWriteTransaction | EFailedBit);

  1802 	r = repository1->CommitTransaction(errorId);

  1803 	TEST2(r, KErrArgument);

  1804 	TEST2(errorId, KInt2);

  1806 	r = TransactionState(repository1);

  1807 	TEST2(r, ENoTransaction);

  1809 	// Begin transaction for repository1

  1810 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1811 	TEST2(r, KErrNone);

  1813 	r = repository1->Set(KInt2, KInt2_InitialValue + 1);

  1814 	TEST2(r, KErrNone);

  1816 	// Set KInt2 to a value of string8 type

  1817 	r = repository1->Set(KInt2, KString8_InitialValue);

  1818 	TEST2(r, KErrArgument);

  1820 	r = TransactionState(repository1);

  1821 	TEST2(r, EReadWriteTransaction | EFailedBit);

  1823 	r = repository1->CommitTransaction(errorId);

  1824 	TEST2(r, KErrArgument);

  1825 	TEST2(errorId, KInt2);

  1827 	r = TransactionState(repository1);

  1828 	TEST2(r, ENoTransaction);

  1830 	// Begin transaction for repository1

  1831 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1832 	TEST2(r, KErrNone);

  1834 	r = repository1->Set(KInt2, KInt2_InitialValue + 1);

  1835 	TEST2(r, KErrNone);

  1837 	// Set KInt2 to a value of string16 type

  1838 	r = repository1->Set(KInt2, KString16_InitialValue);

  1839 	TEST2(r, KErrArgument);

  1841 	r = TransactionState(repository1);

  1842 	TEST2(r, EReadWriteTransaction | EFailedBit);

  1844 	r = repository1->CommitTransaction(errorId);

  1845 	TEST2(r, KErrArgument);

  1846 	TEST2(errorId, KInt2);

  1848 	r = TransactionState(repository1);

  1849 	TEST2(r, ENoTransaction);

  1851 	CleanupStack::PopAndDestroy(repository1);

  1852 	}

  1854 /**

  1855 @SYMTestCaseID SYSLIB-CENREP-CT-0167

  1856 @SYMTestCaseDesc Test Transaction error conditions with move

  1857 @SYMTestPriority High

  1858 @SYMTestActions Start a transaction and perform some problematic move operations. Test to see if it fails transactions or not.

  1859 @SYMTestExpectedResults The test should not fail with any panics

  1860 @SYMPREQ PREQ752

  1861 */

  1862 LOCAL_C void TransactionErrorConditionsForMoveL()

  1863 	{

  1864 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0167 "));

  1865 	TInt r;

  1866 	TUint32 errorId;

  1868 	CRepository* repository1;

  1870 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1872 	// Begin transaction for repository1

  1873 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1874 	TEST2(r, KErrNone);

  1876 	// Move a set of keys which does not exist

  1877 	r = repository1->Move(KMoveSourceDoesntExist, KMoveTarget, KMoveMask, errorId) ;

  1878 	TEST2(r, KErrNotFound);

  1880 	r = TransactionState(repository1);

  1881 	TEST2(r, EReadWriteTransaction);

  1883 	r = repository1->Move(KInt1, KInt1, KMoveMask, errorId) ;

  1884 	TEST2(r, KErrNone);

  1886 	r = TransactionState(repository1);

  1887 	TEST2(r, EReadWriteTransaction);

  1889 	r = repository1->CommitTransaction(errorId);

  1890 	TEST2(r, KErrNone);

  1892 	r = TransactionState(repository1);

  1893 	TEST2(r, ENoTransaction);

  1895 	CleanupStack::PopAndDestroy(repository1);

  1896 	}

  1898 /**

  1899 @SYMTestCaseID SYSLIB-CENREP-CT-0168

  1900 @SYMTestCaseDesc Test move operation with more comprehensive test cases

  1901 @SYMTestPriority High

  1902 @SYMTestActions Start a transaction and try to perform some problematic move operations. Check result of operation.

  1903 @SYMTestExpectedResults The test should not fail with any panics

  1904 @SYMPREQ PREQ752

  1905 */

  1906 LOCAL_C void TransactionConditionsForMoveL()

  1907 	{

  1908 	// More comprehensive test cases for MOVE

  1910 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0168 "));

  1911 	TInt r;

  1912 	TUint32 errorId;

  1913 	TBuf8<16> buf8Val;

  1915 	CRepository* repository1;

  1917 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1919 	// Begin transaction for repository1

  1920 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  1921 	TEST2(r, KErrNone);

  1923 	// Move a set of keys which does not exist

  1924 	r = repository1->Move(KNewString8, KMoveTarget, KMoveMask, errorId);

  1925 	TEST2(r, KErrNotFound);

  1927 	r = TransactionState(repository1);

  1928 	TEST2(r, EReadWriteTransaction);

  1930 	r = repository1->Create(KNewString8, KString8_InitialValue2);

  1931 	TEST2(r, KErrNone);

  1933 	//Move KNewString8 to KMoveTarget

  1934 	r = repository1->Move(KNewString8, KMoveTarget, KMoveMask, errorId);

  1935 	TEST2(r, KErrNone);

  1937 	r = repository1->Get(KNewString8, buf8Val);

  1938 	TEST2(r, KErrNotFound);

  1940 	r = TransactionState(repository1);

  1941 	TEST2(r, EReadWriteTransaction);

  1943 	// Move keys back again

  1944 	r = repository1->Move(KMoveTarget, KNewString8, KMoveMask, errorId);

  1945 	TEST2(r, KErrNone);

  1947 	r = repository1->Get(KNewString8, buf8Val);

  1948 	TEST2(r, KErrNone);

  1949 	TEST(buf8Val==KString8_InitialValue2);

  1951 	r = repository1->CommitTransaction(errorId);

  1952 	TEST2(r, KErrNone);

  1954 	// Reset the test by deleting KNewString8...

  1955 	r = repository1->Delete(KNewString8);

  1956 	TEST2(r, KErrNone);

  1958 	CleanupStack::PopAndDestroy(repository1);

  1959 	}

  1961 /**

  1962 @SYMTestCaseID SYSLIB-CENREP-CT-0169

  1963 @SYMTestCaseDesc Test concurrent read and write transactions

  1964 @SYMTestPriority High

  1965 @SYMTestActions Start a concurrent read write transaction and perform some operations. Check the state of transaction

  1966 @SYMTestExpectedResults The test should not fail with any panics

  1967 @SYMPREQ PREQ752

  1968 */

  1969 LOCAL_C void ConcurrentReadWriteTransactionStatesL()

  1970 	{

  1971 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0169 "));

  1972 	TInt r;

  1973 	TUint32 errorId;

  1974 	TReal getValue;

  1976 	CRepository* repository1;

  1978 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  1980 	// Begin transaction for repository1

  1981 	r = repository1->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

  1982 	TEST2(r, KErrNone);

  1984 	r = TransactionState(repository1);

  1985 	TEST2(r, EConcurrentReadWriteTransaction);

  1987 	r = repository1->Create(KReal2, KReal2_InitialValue);

  1988 	TEST2(r, KErrNone);

  1990 	r = repository1->Get(KReal2, getValue);

  1991 	TEST2(r, KErrNone);

  1993 	// Fail transaction should roll back transaction i.e. Create KReal2 should not work.

  1994 	repository1->FailTransaction();

  1996 	r = TransactionState(repository1);

  1997 	TEST2(r, EConcurrentReadWriteTransaction | EFailedBit);

  1999 	// Commit transaction

  2000 	r = repository1->CommitTransaction(errorId);

  2001 	TEST2(r, KErrAbort);

  2003 	// Try to get a value which should not exist as transaction failed

  2004 	r = repository1->Get(KReal2, getValue);

  2005 	TEST2(r, KErrNotFound);

  2007 	r = TransactionState(repository1);

  2008 	TEST2(r, ENoTransaction);

  2010 	CleanupStack::PopAndDestroy(repository1);

  2011 	}

  2013 /**

  2014 @SYMTestCaseID SYSLIB-CENREP-CT-0170

  2015 @SYMTestCaseDesc Test concurrent read and write transaction with read operations

  2016 @SYMTestPriority High

  2017 @SYMTestActions Start a concurrent read write and a read transaction and perform some read operations. Check the state of transaction

  2018 @SYMTestExpectedResults The test should not fail with any panics

  2019 @SYMPREQ PREQ752

  2020 */

  2021 LOCAL_C void ConcurrentReadWriteTransactionWithReadOperationsL()

  2022 	{

  2023 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENREP-CT-0170 "));

  2024 	TInt r;

  2025 	TUint32 errorId;

  2026 	TReal getValue;

  2028 	CRepository* repository1;

  2029 	CRepository* repository2;

  2030 	CRepository* repository3;

  2032 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  2033 	User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));

  2034 	User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository));

  2036 	// Begin concurrent read write transaction for repository1

  2037 	r = repository1->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

  2038 	TEST2(r, KErrNone);

  2040 	// Begin read transaction for repository2

  2041 	r = repository2->StartTransaction(CRepository::EReadTransaction);

  2043 	r = TransactionState(repository1);

  2044 	TEST2(r, EConcurrentReadWriteTransaction);

  2046 	r = TransactionState(repository2);

  2047 	TEST2(r, EReadTransaction);

  2049 	// Create value in with a concurrent read write transaction

  2050 	r = repository1->Create(KReal2, KReal2_InitialValue);

  2051 	TEST2(r, KErrNone);

  2053 	// Get value set using another transaction

  2054 	r = repository2->Get(KReal1, getValue);

  2055 	TEST2(r, KErrNone);

  2056 	TEST(getValue == KReal1_InitialValue);

  2058 	// Get value set outside of a transaction using repository3

  2059 	r = repository3->Get(KReal1, getValue);

  2060 	TEST2(r, KErrNone);

  2061 	TEST(getValue == KReal1_InitialValue);

  2063 	// Get value set within another transaction but not commited, within a transaction

  2064 	r = repository2->Get(KReal2, getValue);

  2065 	TEST2(r, KErrNotFound);

  2067 	// Get value set within another transaction but not commited, outside of a transaction

  2068 	r = repository3->Get(KReal2, getValue);

  2069 	TEST2(r, KErrNotFound);

  2071 	// Commit repository2

  2072 	r = repository2->CommitTransaction(errorId);

  2073 	TEST2(r, KErrNone);

  2075 	// Commit repository1

  2076 	r = repository1->CommitTransaction(errorId);

  2077 	TEST2(r, KErrNone);

  2079 	CleanupStack::PopAndDestroy(repository3);

  2080 	CleanupStack::PopAndDestroy(repository2);

  2081 	CleanupStack::PopAndDestroy(repository1);

  2083 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  2085 	// Check that value was persisted

  2086 	r = repository1->Get(KReal2, getValue);

  2087 	TEST2(r, KErrNone);

  2088 	TEST(getValue == KReal2_InitialValue);

  2090 	// Delete KReal2 to reset available test case variables

  2091 	r = repository1->Delete(KReal2);

  2092 	TEST2(r, KErrNone);

  2094 	CleanupStack::PopAndDestroy(repository1);

  2095 	}

  2097 LOCAL_C void Defect058796()

  2098 	{

  2099 	TInt r;

  2100 	TUint32 errorId;

  2102 	TBuf8<2> buf8ValSmall;

  2103 	TBuf16<2> buf16ValSmall;

  2105 	TBuf8<16> buf8Val;

  2106 	TBuf16<16> buf16Val;

  2108 	TInt length;

  2110 	CRepository* repository1;

  2112 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  2114 	// Start a read write transaction

  2115 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  2116 	TEST2(r, KErrNone);

  2118 	// Try to get a string value using a TBuf8 with length which is too small

  2119 	r = repository1->Get(KString8, buf8ValSmall, length);

  2120 	TEST2(r, KErrOverflow);

  2121 	TEST(buf8ValSmall == KString8_Small_Value);

  2122 	TEST2(length, 13);

  2124 	// Try to get a string value using a TBuf16 with length which is too small

  2125 	r = repository1->Get(KString16, buf16ValSmall, length);

  2126 	TEST2(r, KErrOverflow);

  2127 	TEST(buf16ValSmall == KString16_Small_Value);

  2128 	TEST2(length, 13);

  2130 	// Set KNewString16 and KNewString8

  2131 	r = repository1->Create(KNewString16, KString16_InitialValue2);

  2132 	TEST2(r, KErrNone);

  2133 	r = repository1->Create(KNewString8, KString8_InitialValue2);

  2134 	TEST2(r, KErrNone);

  2136 	// Try to get KNewString16 with a TBuf16 which is a suitable size

  2137 	r = repository1->Get(KNewString16, buf16Val, length);

  2138 	TEST2(r, KErrNone);

  2139 	TEST(buf16Val == KString16_InitialValue2);

  2140 	TEST2(length, 16);

  2142 	// Try to get KNewString8 with a TBuf8 which is a suitable size

  2143 	r = repository1->Get(KNewString8, buf8Val, length);

  2144 	TEST2(r, KErrNone);

  2145 	TEST(buf8Val == KString8_InitialValue2);

  2146 	TEST2(length, 16);

  2148 	// Commit the transaction

  2149 	r = repository1->CommitTransaction(errorId);

  2150 	TEST2(r, KErrNone);

  2152 	// Delete KNewString8 to reset available test case variables

  2153 	r = repository1->Delete(KNewString8);

  2154 	TEST2(r, KErrNone);

  2156 	// Delete KNewString16 to reset available test case variables

  2157 	r = repository1->Delete(KNewString16);

  2158 	TEST2(r, KErrNone);

  2160 	CleanupStack::PopAndDestroy(repository1);

  2161 	}

  2164 LOCAL_C void UnloadedPolicyKeyTest()

  2165 	{

  2166 	TInt r;

  2167 	TUint32 KeyId;

  2168 	CRepository* repository1;

  2170 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  2172 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  2173 	TEST2(r, KErrNone);

  2175 	//Creating Single Policy Key

  2176 	r = repository1->Create(KInt5, KInt5_SecondValue );

  2177 	TEST2(r,KErrNone);

  2179 	//Creating Ranged Policy Key

  2180 	r = repository1->Create(KInt3, KInt3_InitialValue);

  2181 	TEST2(r, KErrNone);

  2183 	//Creating Default Policy Key

  2184 	r = repository1->Create(KInt4, KInt4_InitialValue);

  2185 	TEST2(r,KErrNone);

  2187 	//Waiting for enough time for the repository to be evicted

  2188 	User::After(1000000);

  2190 	r = repository1->CommitTransaction(KeyId);

  2191 	TEST2(r, KErrNone);

  2192 	TEST2(KeyId, 3);

  2194 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  2195 	TEST2(r, KErrNone);

  2197 	//Deleting Default Policy Key

  2198 	r = repository1->Delete(KInt5);

  2199 	TEST2(r, KErrNone);

  2201 	//Deleting Ranged Policy Key

  2202 	r = repository1->Delete(KInt3);

  2203 	TEST2(r, KErrNone);

  2205 	//Deleting Single Policy Key

  2206 	r = repository1->Delete(KInt4);

  2207 	TEST2(r, KErrNone);

  2209 	r = repository1->CommitTransaction(KeyId);

  2210 	TEST2(r, KErrNone);

  2211 	TEST2(KeyId, 3);

  2213 	CleanupStack::PopAndDestroy(repository1);

  2214 	}

  2216 /**

  2217 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3239

  2218 @SYMTestCaseDesc Test for corrupt access policy when a repository is evicted and reloaded during a transaction

  2219 @SYMTestPriority High

  2220 @SYMTestActions Start a transaction and create keys with different access policies but evicts the repository prior to commiting it

  2221 @SYMTestExpectedResults The test should not fail with any panics

  2222 @SYMDEF DEF095718

  2223 */

  2224 LOCAL_C void Defect095718()

  2225 	{

  2226 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3239 "));

  2227 	CRepository* repository1;

  2228 	TInt r;

  2229 	TUint32 KeyId;

  2230 	TBuf<KMaxFileName> src1;

  2231 	TBuf<KMaxFileName> dest1;

  2232 	_LIT(KDest, "c:\\private\\10202BE9\\centrep.ini");

  2233 	_LIT(KSrc, "z:\\private\\10202BE9\\centrepcache.ini10");

  2234 	_LIT( KCentralRepositoryServerName, "Centralrepositorysrv");

  2235 	const TInt test_total = 3; //The test runs 3 times

  2237 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  2239 	r = repository1->StartTransaction(CRepository::EReadWriteTransaction);

  2240 	TEST2(r, KErrNone);

  2242 	//Deleting the existing key so that we can re-create it later

  2243 	r = repository1->Delete(KInt5);

  2244 	TEST2(r, KErrNone);

  2246 	r = repository1->CommitTransaction(KeyId);

  2247 	TEST2(r, KErrNone);

  2248 	TEST2(KeyId, 1);

  2250 	CleanupStack::PopAndDestroy(repository1);

  2252 	//Kill the server so that a new .ini file can be loaded when the server restarts

  2253 	KillProcess(KCentralRepositoryServerName);

  2254 	//Copy the .ini file from z: to c: so the server will load it

  2255 	RFs FileServer;

  2256 	FileServer.Connect();

  2257 	CleanupClosePushL(FileServer);

  2258 	CFileMan* fm = CFileMan::NewL(FileServer);

  2259 	CleanupStack::PushL(fm);

  2260 	dest1.Copy(KDest);

  2261 	src1.Copy(KSrc);

  2262 	r = fm->Delete(dest1);

  2263 	User::LeaveIfError(fm->Copy(src1,dest1));

  2264 	r = fm->Attribs(dest1, KEntryAttArchive, KEntryAttReadOnly, TTime(0), CFileMan::ERecurse);

  2265 	TEST2(r, KErrNone);

  2267 	//Test for unloaded policy key a set amount of times

  2268 	for(TInt i=0; i<test_total; i++)

  2269 		{

  2270 		//Check that the policy key used isn't from the unloaded/evicted repository

  2271 		UnloadedPolicyKeyTest();

  2272 		}

  2274 	//Deleting the ini file so that default values will be used again

  2275 	r = fm->Delete(dest1);

  2276 	TEST2(r, KErrNone);

  2278 	//Killing the server and restarting it so that default values are loaded

  2279 	KillProcess(KCentralRepositoryServerName);

  2280 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  2282 	CleanupStack::PopAndDestroy(repository1);

  2283 	CleanupStack::PopAndDestroy(fm);

  2284 	CleanupStack::PopAndDestroy();

  2285 	}

  2287 /**

  2288 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3243

  2289 @SYMTestCaseDesc Test that a repository client can be reused after a CommitTransaction and CancelTransaction Operation involving mulitple concurrent transactions

  2290 @SYMTestPriority High

  2291 @SYMTestExpectedResults The test should not fail with any panics

  2292 @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

  2293 @SYMDEF DEF098242

  2294 */

  2295 LOCAL_C void Defect098242()

  2296 	{

  2297 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3243 "));

  2298 	TInt r;

  2299 	TUint32 KeyId;

  2300 	CRepository* repository1;

  2301 	CRepository* repository2;

  2302 	CRepository* repository3;

  2303 	User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository));

  2304 	User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository));

  2305 	User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository));

  2307 	//Starting 3 transactions

  2308 	r = repository1->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

  2309 	TEST2(r, KErrNone);

  2311 	r = repository2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

  2312 	TEST2(r, KErrNone);

  2314 	r = repository3->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

  2315 	TEST2(r, KErrNone);

  2317 	//Adding values in each

  2318 	r = repository1->Create(KInt2, KInt2_InitialValue);

  2319 	TEST2(r, KErrNone);

  2321 	r = repository2->Create(KInt3, KInt3_InitialValue);

  2322 	TEST2(r, KErrNone);

  2324 	r = repository3->Create(KInt4, KInt4_InitialValue);

  2325 	TEST2(r, KErrNone);

  2327 	//Cancel the transaction of the first client

  2328 	repository1->CancelTransaction();

  2330 	//Committing the other 2 transactions

  2331 	r = repository2->CommitTransaction(KeyId);

  2332 	TEST2(r, KErrNone);

  2333 	TEST2(KeyId,1);

  2335 	r = repository3->CommitTransaction(KeyId);

  2336 	TEST2(r, KErrLocked);

  2337 	TEST2(KeyId,KUnspecifiedKey);

  2339 	//Try Re-starting a transaction with the clients

  2340 	r = repository1->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

  2341 	TEST2(r, KErrNone);

  2342 	r = repository1->CommitTransaction(KeyId);

  2343 	TEST2(r, KErrNone);

  2344 	TEST2(KeyId,0);

  2346 	r = repository2->StartTransaction(CRepository::EConcurrentReadWriteTransaction);

  2347 	TEST2(r, KErrNone);

  2349 	//Deleting the key so the repository is in the same state as prior to the function call

  2350 	r = repository2->Delete(KInt3);

  2351 	TEST2(r, KErrNone);

  2353 	//Checking that these values were not made persistent

  2354 	r = repository2->Delete(KInt2);

  2355 	TEST2(r, KErrNotFound);

  2357 	r = repository2->Delete(KInt4);

  2358 	TEST2(r, KErrNotFound);

  2360 	r = repository2->CommitTransaction(KeyId);

  2361 	TEST2(r, KErrNone);

  2362 	TEST2(KeyId,1);

  2364 	r = repository1->Reset();

  2365 	TEST2(r, KErrNone);

  2367 	CleanupStack::PopAndDestroy(repository3);

  2368 	CleanupStack::PopAndDestroy(repository2);

  2369 	CleanupStack::PopAndDestroy(repository1);

  2370 	}

  2372 /**

  2373 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4011

  2374 @SYMTestCaseDesc  Test for PDEF112273 - When creating commsdat Backup & restore metadata is not set correctly

  2375 @SYMTestPriority High

  2376 @SYMTestActions The test uses the 00112273.TXT ini file, where the default meta data value is set to be 0x00100000.

  2377 				The test creates a CRepository object with UID=0x00112273 and creates a single integer setting with

  2378 				value 1 and no meta data. In this case the setting meta data should be the default one - 0x00100000.

  2379 				Then the test begins a transaction and within the transaction: the setting gets deleted and then - recreated

  2380 				again but with a different value and no meta data. The transaction is commited.

  2381 				The setting meta data value should be 0x00100000 within the transaction and outisde the transaction.

  2382 @SYMTestExpectedResults The test should not fail with any panics

  2383 @SYMDEF PDEF112273

  2384 */

  2385 void DoPDEF112273Test1L()

  2386 	{

  2387 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4011 "));

  2388 	const TUid KTestCenRepUid = {0x00112273};

  2389 	CRepository* repository = CRepository::NewLC(KTestCenRepUid);

  2390 	//Create a setting

  2391 	const TInt KTestSettingId = 123;

  2392 	TInt err = repository->Create(KTestSettingId, 1);

  2393 	TEST2(err, KErrNone);

  2395 	const TUint32 KDefaultMeta = 0x00100000;

  2396 	//Check setting meta. The meta value should be KDefaultMeta.

  2397 	TUint32 meta = 0;

  2398 	err = repository->GetMeta(KTestSettingId, meta);

  2399 	TEST2(err, KErrNone);

  2400 	TEST2(meta, KDefaultMeta);

  2402 	err = repository->StartTransaction(CRepository::EReadWriteTransaction);

  2403 	TEST2(err, KErrNone);

  2404 	//In a transaction. Delete the created setting.

  2405 	err = repository->Delete(KTestSettingId);

  2406 	TEST2(err, KErrNone);

  2407 	//In a transaction. Re-create the deleted setting but with a different value.

  2408 	err = repository->Create(KTestSettingId, 2);

  2409 	TEST2(err, KErrNone);

  2410 	//In a transaction. Get the setting meta. The meta value should be KDefaultMeta.

  2411 	err = repository->GetMeta(KTestSettingId, meta);

  2412 	TEST2(err, KErrNone);

  2413 	TEST2(meta, KDefaultMeta);

  2415 	TUint32 keyInfo = 0;

  2416 	err = repository->CommitTransaction(keyInfo);

  2417 	TEST2(err, KErrNone);

  2419 	//Not in transaction. Get the setting meta. The meta value should be KDefaultMeta.

  2420 	err = repository->GetMeta(KTestSettingId, meta);

  2421 	TEST2(err, KErrNone);

  2422 	TEST2(meta, KDefaultMeta);

  2424 	CleanupStack::PopAndDestroy(repository);

  2425 	}

  2427 /**

  2428 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4012

  2429 @SYMTestCaseDesc  Test for PDEF112273 - When creating commsdat Backup & restore metadata is not set correctly

  2430 @SYMTestPriority High

  2431 @SYMTestActions The test uses the 00112273.TXT ini file, where the default meta data value is set to be 0x00100000.

  2432 				The test creates a CRepository object with UID=0x00112273.

  2433 				Then the test begins a transaction and within the transaction: setting with id=0x0000001 (from the ini file)

  2434 				and setting meta=0x00200000 will be deleted and then recreated again with a different value and no meta.

  2435 				The transaction is commited.

  2436 				The setting meta data value should be 0x00200000 within the transaction and outisde the transaction.

  2437 @SYMTestExpectedResults The test should not fail with any panics

  2438 @SYMDEF PDEF112273

  2439 */

  2440 void DoPDEF112273Test2L()

  2441 	{

  2442 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4012 "));

  2443 	const TUid KTestCenRepUid = {0x00112273};

  2444 	CRepository* repository = CRepository::NewLC(KTestCenRepUid);

  2445 	//Ini file - KTestSettingId setting properties:

  2446 	const TInt KTestSettingId = 0x0000001;

  2447 	const TInt KTestSettingVal = 1;

  2448 	const TUint32 KSettingMeta = 0x00200000;

  2449 	//Check setting meta. The meta value should be KDefaultMeta.

  2450 	TUint32 meta = 0;

  2451 	TInt err = repository->GetMeta(KTestSettingId, meta);

  2452 	TEST2(err, KErrNone);

  2453 	TEST2(meta, KSettingMeta);

  2455 	err = repository->StartTransaction(CRepository::EReadWriteTransaction);

  2456 	TEST2(err, KErrNone);

  2457 	//In a transaction. Delete the created setting.

  2458 	err = repository->Delete(KTestSettingId);

  2459 	TEST2(err, KErrNone);

  2460 	//In a transaction. Re-create the deleted setting with different value.

  2461 	err = repository->Create(KTestSettingId, KTestSettingVal + 1);

  2462 	TEST2(err, KErrNone);

  2463 	//In a transaction. Get the setting meta. The meta value should be KSettingMeta.

  2464 	err = repository->GetMeta(KTestSettingId, meta);

  2465 	TEST2(err, KErrNone);

  2466 	TEST2(meta, KSettingMeta);

  2468 	TUint32 keyInfo = 0;

  2469 	err = repository->CommitTransaction(keyInfo);

  2470 	TEST2(err, KErrNone);

  2472 	//Not in transaction. Get the setting meta. The meta value should be KSettingMeta.

  2473 	err = repository->GetMeta(KTestSettingId, meta);

  2474 	TEST2(err, KErrNone);

  2475 	TEST2(meta, KSettingMeta);

  2477 	CleanupStack::PopAndDestroy(repository);

  2478 	}

  2480 /**

  2481 @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4013

  2482 @SYMTestCaseDesc  Test for PDEF112273 - When creating commsdat Backup & restore metadata is not set correctly

  2483 @SYMTestPriority High

  2484 @SYMTestActions The test uses the 00112273.TXT ini file, where the default meta data value is set to be 0x00100000.

  2485 				The test creates a CRepository object with UID=0x00112273.

  2486 				Then the test begins a transaction and within the transaction: a new setting with no meta is created.

  2487 				The transaction is commited.

  2488 				The setting meta data value should be 0x00100000 within the transaction and outisde the transaction.

  2489 @SYMTestExpectedResults The test should not fail with any panics

  2490 @SYMDEF PDEF112273

  2491 */

  2492 void DoPDEF112273Test3L()

  2493 	{

  2494 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4013 "));

  2495 	const TUid KTestCenRepUid = {0x00112273};

  2496 	CRepository* repository = CRepository::NewLC(KTestCenRepUid);

  2498 	TInt err = repository->StartTransaction(CRepository::EReadWriteTransaction);

  2499 	TEST2(err, KErrNone);

  2500 	//In a transaction. Create a setting

  2501 	const TInt KTestSettingId = 1234;

  2502 	err = repository->Create(KTestSettingId, 1);

  2503 	TEST2(err, KErrNone);

  2505 	const TUint32 KDefaultMeta = 0x00100000;

  2506 	TUint32 meta = 0;

  2507 	//In a transaction. Get the setting meta. The meta value should be KDefaultMeta.

  2508 	err = repository->GetMeta(KTestSettingId, meta);

  2509 	TEST2(err, KErrNone);

  2510 	TEST2(meta, KDefaultMeta);

  2512 	TUint32 keyInfo = 0;

  2513 	err = repository->CommitTransaction(keyInfo);

  2514 	TEST2(err, KErrNone);

  2516 	//Not in transaction. Get the setting meta. The meta value should be KDefaultMeta.

  2517 	err = repository->GetMeta(KTestSettingId, meta);

  2518 	TEST2(err, KErrNone);

  2519 	TEST2(meta, KDefaultMeta);

  2521 	CleanupStack::PopAndDestroy(repository);

  2522 	}

  2524 void PDEF112273L()

  2525 	{

  2526 	DoPDEF112273Test1L();

  2527 	DoPDEF112273Test2L();

  2528 	DoPDEF112273Test3L();

  2529 	}

  2531 LOCAL_C void TransactionsFuncTestsL()

  2532 	{

  2533 	TheTest.Next(_L("Committing changes causes other sessions' active transactions to fail with KErrLocked"));

  2534 	CommittingChangesFailsOtherTransactionsL();

  2536 	TheTest.Next(_L("Committing no changes does not fail other sessions' active transactions"));

  2537 	CommittingNoChangesDoesNotFailOtherTransactionsL();

  2539 	TheTest.Start(_L("Create values using transaction"));

  2540 	CreateValueUsingTransactionL();

  2542 	TheTest.Next(_L("Get transaction state in transactions and test for rollback in failed transactions"));

  2543 	TransactionStateAndRollBackL();

  2545 	TheTest.Next(_L("Multiple Read-Write Transaction error and panic conditions"));

  2546 	TransactionPanicConditionsThread();

  2548 	TheTest.Next(_L("Commit Transaction error and panic condition"));

  2549 	CommitTransactionPanicConditionsThread();

  2551 	TheTest.Next(_L("Clean up using rollback and failed transactions"));

  2552 	CleanupRollBackAndFailTransactionL();

  2554 	TheTest.Next(_L("Multiple Read Transaction conditions"));

  2555 	ReadTransactionConditionsL();

  2557 	TheTest.Next(_L("Multiple Read Transaction with upgrade error conditions"));

  2558 	UpgradeReadTransactionErrorConditionsL();

  2560 	TheTest.Next(_L("Transaction conditions with read operations"));

  2561 	TransactionConditionsForReadL();

  2563 	TheTest.Next(_L("Transaction error conditions with get operations"));

  2564 	TransactionErrorConditionsForGetL();

  2566 	TheTest.Next(_L("Transaction error conditions with find operations"));

  2567 	TransactionErrorConditionsForFindL();

  2569 	TheTest.Next(_L("Transaction error conditions with findeq operations"));

  2570 	TransactionErrorConditionsForFindEqL();

  2572 	TheTest.Next(_L("Transaction error conditions with findneq operations"));

  2573 	TransactionErrorConditionsForFindNeqL();

  2575 	TheTest.Next(_L("Transaction error conditions with create operations"));

  2576 	TransactionErrorConditionsForCreateL();

  2578 	TheTest.Next(_L("Transaction error conditions with delete operations"));

  2579 	TransactionErrorConditionsForDeleteL();

  2581 	TheTest.Next(_L("Transaction error conditions with set operations"));

  2582 	TransactionErrorConditionsForSetL();

  2584 	TheTest.Next(_L("Transaction error conditions with move operations"));

  2585 	TransactionErrorConditionsForMoveL();

  2587 	TheTest.Next(_L("Transaction conditions with move operations"));

  2588 	TransactionConditionsForMoveL();

  2590 	// Concurrent read/write transactions...

  2592 	TheTest.Next(_L("Concurrent read/write transaction"));

  2593 	ConcurrentReadWriteTransactionStatesL();

  2595 	TheTest.Next(_L("Concurrent read/write transaction with other reads operations"));

  2596 	ConcurrentReadWriteTransactionWithReadOperationsL();

  2598 	// Test cases for defects ...

  2600 	TheTest.Next(_L("Tests for get functions, as required in DEF058796"));

  2601 	Defect058796();

  2603 	TheTest.Next(_L("Checks for corrupt policy keys, as required in DEF095718"));

  2604 	Defect095718();

  2606 	TheTest.Next(_L("Test for restarting a transaction from the same client, as required in DEF098242"));

  2607 	Defect098242();

  2609 	TheTest.Next(_L("PDEF112273 - When creating commsdat Backup & restore metadata is not set correctly"));

  2610 	PDEF112273L();

  2612 	TheTest.End();

  2613 	}

  2615 LOCAL_C void MainL()

  2616 	{

  2617 	TheTest.Start(_L("Central Repository transactions functional tests"));

  2618 	CleanupCDriveL();

  2619 	TransactionsFuncTestsL();

  2621 	TheTest.Next(_L("Clean out C: files"));

  2622 	CleanupCDriveL();

  2624 	TheTest.End();

  2625 	TheTest.Close();

  2626 	}

  2628 TInt E32Main()

  2629 	{

  2630 	__UHEAP_MARK;

  2631 	CTrapCleanup* cleanup = CTrapCleanup::New();

  2632 	if(!cleanup)

  2633 		return KErrNoMemory;

  2635 	TRAPD(err, MainL());

  2636 	if (err != KErrNone)

  2637 		User::Panic(_L("Testing failed: "), err);

  2639 	delete cleanup;

  2640 	__UHEAP_MARKEND;

  2642 	return 0;

  2643 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--