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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include "t_cenrep_helper.h"

#include <centralrepository.h>

#include <e32test.h>

#include <f32file.h>

#include <bautils.h>

#include "e32math.h"

#include "srvparams.h"

#include "transstate.h"

#include "clientrequest.h"

#include "panic.h"

//#define Additional_Test

using namespace NCentralRepositoryConstants;

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

const TUid KUidTestRepository 	= { 0x0000101 };

//

// Repository A

//

const TUint32 KUnprotectedSettingsMask = 0xFF000000 ;

const TInt KThreadStackSize	=0x2000; // 8k

const TInt KThreadMinHeapSize	=0x4000; // 16k

const TInt KThreadMaxHeapSize	=0xa000; // 60k

const TUint32 KInt1 = 1;

const TInt KInt1_InitialValue = 1;

const TUint32 KReal1 = 2;

const TReal KReal1_InitialValue = 2.732;

const TUint32 KString8 = 5;

const TUint32 KString16 = 6;

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

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

const TInt KInt2 = 3;

const TInt KInt2_InitialValue = 20;

const TUint32 KReal2 = 28;

const TReal KReal2_InitialValue = 2.5;

const TReal KReal2_SecondValue = 3.5;

const TUint32 KNewString8 = 21;

const TUint32 KNewString16 = 22;

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

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

_LIT(KString16_Small_Value, "te");

_LIT8(KString8_Small_Value, "te");

const TUint32 KMoveTarget            = 0x02000001  ;

const TUint32 KMoveSourceDoesntExist = 0x01000000 ;

const TUint32 KMoveMask              = 0xFF0000FF ;

const TUint32 KInt3 = 10; //Ranged Policy Key

const TInt KInt3_InitialValue = 34;

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

const TInt KInt4_InitialValue = 10;

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

const TInt KInt5_SecondValue = 123;

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Test macroses and functions

LOCAL_C void CheckL(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		CleanupCDriveL();

		TheTest(EFalse, aLine);

		}

	}

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

	{

	if(aValue != aExpected)

		{

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

		CleanupCDriveL();

		TheTest(EFalse, aLine);

		}

	}

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

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

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

typedef void (*TRepositoryFunc)(CRepository&);

void ChangeByCreate(CRepository& aRep)

	{

	TInt r;

	// Create a setting outside of a transaction

	r = aRep.Create(KReal2, KReal2_InitialValue);

	TEST2(r, KErrNone);

	// confirm setting created

	TReal value;

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNone);

	TEST(value == KReal2_InitialValue);

	}

void ChangeBySet(CRepository& aRep)

	{

	TInt r;

	// Set a value outside of a transaction

	r = aRep.Set(KReal2, KReal2_SecondValue);

	TEST2(r, KErrNone);

	// confirm value changed

	TReal value;

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNone);

	TEST(value == KReal2_SecondValue);

	}

void ChangeByDelete(CRepository& aRep)

	{

	TInt r;

	// Delete a setting outside of a transaction

	r = aRep.Delete(KReal2);

	TEST2(r, KErrNone);

	// confirm it's deleted

	TReal value;

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNotFound);

	}

void ChangeByTransaction(CRepository& aRep)

	{

	TInt r;

	TUint32 keyInfo;

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

	// within function CommittingChangesFailsOtherTransactions.

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

	TEST2(r, KErrLocked);

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

	TEST2(r, KErrLocked);

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

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

	TEST2(r, KErrNone);

	r = TransactionState(&aRep);

	TEST2(r, EConcurrentReadWriteTransaction);

	// Create a setting within transaction

	r = aRep.Create(KReal2, KReal2_InitialValue);

	TEST2(r, KErrNone);

	// confirm setting created

	TReal value;

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNone);

	TEST(value == KReal2_InitialValue);

	r = aRep.CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

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

	// re-confirm setting is still there

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNone);

	TEST(value == KReal2_InitialValue);

	}

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

void ChangeByAsyncTransaction(CRepository& aRep)

	{

	TInt r;

	CRepository::TTransactionKeyInfoBuf keyInfoBuf;

	TRequestStatus status;

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

	// within function CommittingChangesFailsOtherTransactions.

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

	User::WaitForRequest(status);

	TEST2(status.Int(), KErrLocked);

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

	User::WaitForRequest(status);

	TEST2(status.Int(), KErrLocked);

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

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

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

	User::WaitForRequest(status);

	TEST2(status.Int(), KErrNone);

	r = TransactionState(&aRep);

	TEST2(r, EConcurrentReadWriteTransaction);

	// Create a setting within transaction

	r = aRep.Create(KReal2, KReal2_InitialValue);

	TEST2(r, KErrNone);

	// confirm setting created

	TReal value;

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNone);

	TEST(value == KReal2_InitialValue);

	aRep.CommitTransaction(keyInfoBuf, status);

	User::WaitForRequest(status);

	TEST2(status.Int(), KErrNone);

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

	// re-confirm setting is still there

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNone);

	TEST(value == KReal2_InitialValue);

	}

void ChangeByReset(CRepository& aRep)

	{

	TInt r;

	// Delete a setting outside of a transaction

	r = aRep.Reset(KReal2);

	TEST2(r, KErrNone);

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

	TReal value;

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNotFound);

	}

void ChangeByResetAll(CRepository& aRep)

	{

	TInt r;

	// Delete a setting outside of a transaction

	r = aRep.Reset();

	TEST2(r, KErrNone);

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

	TReal value;

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNotFound);

	}

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

// transactions with reason KErrLocked, and correctly discard changes

LOCAL_C void CallFuncCheckOtherTransactionsFail(TRepositoryFunc ChangeFunc, CRepository& aCommittingRepository)

	{

	TInt r;

	TUint32 keyInfo;

	CRepository* repository1;

	CRepository* repository2;

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

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

	// Start two types of transaction

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

	TEST2(r, KErrNone);

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

	TEST2(r, KErrNone);

	// check transactions haven't failed yet.

	r = TransactionState(repository1);

	TEST2(r, EReadWriteTransaction);

	r = TransactionState(repository2);

	TEST2(r, EConcurrentReadWriteTransaction);

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

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

	TEST2(r, KErrNone);

	TInt value;

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

	TEST2(r, KErrNone);

	TEST(value == KInt1_InitialValue);

	(*ChangeFunc)(aCommittingRepository);

	// check transactions have now failed

	r = TransactionState(repository1);

	TEST2(r, EReadWriteTransaction | EFailedBit);

	r = TransactionState(repository2);

	TEST2(r, EConcurrentReadWriteTransaction | EFailedBit);

	// operations should abort after failing

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

	TEST2(r, KErrAbort);

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

	TEST2(r, KErrAbort);

	// commits should fail with KErrLocked

	r = repository2->CommitTransaction(keyInfo);

	TEST2(r, KErrLocked);

	TEST2(keyInfo, KUnspecifiedKey);

	r = repository1->CommitTransaction(keyInfo);

	TEST2(r, KErrLocked);

	TEST2(keyInfo, KUnspecifiedKey);

	// integer should not be persistent

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

	TEST2(r, KErrNotFound);

	CleanupStack::PopAndDestroy(repository2);

	CleanupStack::PopAndDestroy(repository1);

	}

/**

@SYMTestCaseID SYSLIB-CENREP-CT-0150

@SYMTestCaseDesc Check committing changes causes other transactions to fail.

@SYMTestPriority High

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

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

@SYMTestExpectedResults The test should not fail with any panics

@SYMPREQ PREQ752

*/

LOCAL_C void CommittingChangesFailsOtherTransactionsL()

	{

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

	CRepository* repository;

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

	repository->Reset();

	// non-transaction create should fail active transactions

	CallFuncCheckOtherTransactionsFail(ChangeByCreate, *repository);

	// non-transaction set should fail active transactions

	CallFuncCheckOtherTransactionsFail(ChangeBySet, *repository);

	// non-transaction delete should fail active transactions

	CallFuncCheckOtherTransactionsFail(ChangeByDelete, *repository);

	// transaction commit with changes should fail active transactions

	CallFuncCheckOtherTransactionsFail(ChangeByTransaction, *repository);

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

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

	CallFuncCheckOtherTransactionsFail(ChangeByAsyncTransaction, *repository);

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

	CallFuncCheckOtherTransactionsFail(ChangeByReset, *repository);

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

	// reset all should fail active transactions

	CallFuncCheckOtherTransactionsFail(ChangeByResetAll, *repository);

	CleanupStack::PopAndDestroy(repository);

	}

void NoChangeByTransactionCreateDelete(CRepository& aRep)

	{

	TInt r;

	TUint32 keyInfo;

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

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

	TEST2(r, KErrNone);

	r = TransactionState(&aRep);

	TEST2(r, EConcurrentReadWriteTransaction);

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

	ChangeByCreate(aRep);

	ChangeByDelete(aRep);

	r = aRep.CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

	TEST2(keyInfo, 0); // no changes

	}

void NoChangeByTransactionSetSameValue(CRepository& aRep)

	{

	TInt r;

	TUint32 keyInfo;

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

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

	TEST2(r, KErrNone);

	r = TransactionState(&aRep);

	TEST2(r, EConcurrentReadWriteTransaction);

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

	ChangeBySet(aRep);

	r = aRep.CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

	TEST2(keyInfo, 0); // no changes

	}

void NoChangeByReadTransaction(CRepository& aRep)

	{

	TInt r;

	TUint32 keyInfo;

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

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

	TEST2(r, KErrNone);

	r = TransactionState(&aRep);

	TEST2(r, EReadTransaction);

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

	TReal value;

	r = aRep.Get(KReal2, value);

	TEST2(r, KErrNone);

	TEST(value == KReal2_InitialValue);

	r = aRep.CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

	TEST2(keyInfo, 0); // no changes

	}

void NoChangeByEmptyWriteTransaction(CRepository& aRep)

	{

	TInt r;

	TUint32 keyInfo;

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

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

	TEST2(r, KErrLocked);

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

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

	TEST2(r, KErrNone);

	r = TransactionState(&aRep);

	TEST2(r, EConcurrentReadWriteTransaction);

	// make no changes before committing

	r = aRep.CommitTransaction(keyInfo);

	TEST2(r, KErrNone);

	TEST2(keyInfo, 0); // no changes

	}

// tests that changes made by calling ChangeFunc with aCommittingRepository

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

LOCAL_C void CallFuncCheckOtherTransactionsDoNotFail(TRepositoryFunc ChangeFunc, CRepository& aCommittingRepository)

	{

	TInt r;

	CRepository::TTransactionKeyInfoBuf keyInfoBuf;

	TUint32 keyInfo;

	TRequestStatus status;

	CRepository* repository1;

	CRepository* repository2;

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

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

	// Start two types of transaction and wait for completion

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

	TEST2(r, KErrNone);

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

	User::WaitForRequest(status);

	TEST2(status.Int(), KErrNone);

	// create values in repository2's transaction cache

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

	TEST2(r, KErrNone);

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

	TEST2(r, KErrNone);

	// check transactions not failed

	r = TransactionState(repository1);

	TEST2(r, EReadTransaction);

	r = TransactionState(repository2);

	TEST2(r, EConcurrentReadWriteTransaction);

	(*ChangeFunc)(aCommittingRepository);

	// create setting in repository 1's cache

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

	TEST2(r, KErrNone);

	// check transactions not failed & Read upgraded to ReadWrite

	r = TransactionState(repository1);

	TEST2(r, EReadWriteTransaction);

	r = TransactionState(repository2);

	TEST2(r, EConcurrentReadWriteTransaction);

	// commit repository2 asynchronously

	repository2->CommitTransaction(keyInfoBuf, status);

	User::WaitForRequest(status);

	TEST2(status.Int(), KErrNone);

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

	// check transaction2 finished, transaction 1 failed

	r = TransactionState(repository1);

	TEST2(r, EReadWriteTransaction | EFailedBit);

	r = TransactionState(repository2);

	TEST2(r, ENoTransaction);

	// operations on repository 1 should abort after failing

	TInt intValue;

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

	TEST2(r, KErrAbort);

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

	TEST2(r, KErrAbort);

	// commit of repository 1 should fail with KErrLocked

	r = repository1->CommitTransaction(keyInfo);

	TEST2(r, KErrLocked);

	TEST2(keyInfo, KUnspecifiedKey);

	// check changes by repository 2 are still present

	TBuf8<40> buf8Value;

	TBuf16<40> buf16Value;

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

	TEST2(r, KErrNone);

	TEST(buf8Value == KString8_InitialValue);

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

	TEST2(r, KErrNone);

	TEST(buf16Value == KString16_InitialValue);

	CleanupStack::PopAndDestroy(repository2);

	CleanupStack::PopAndDestroy(repository1);

	}

/**

@SYMTestCaseID SYSLIB-CENREP-CT-0151

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

@SYMTestPriority High

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

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

@SYMTestExpectedResults The test should not fail with any panics

@SYMPREQ PREQ752

*/

LOCAL_C void CommittingNoChangesDoesNotFailOtherTransactionsL()

	{

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

	CRepository* repository;

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

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

	repository->Reset();

	CallFuncCheckOtherTransactionsDoNotFail(NoChangeByTransactionCreateDelete, *repository);

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

	repository->Reset();

	ChangeByCreate(*repository);

	ChangeBySet(*repository);

	CallFuncCheckOtherTransactionsDoNotFail(NoChangeByTransactionSetSameValue, *repository);

	// committing a Read transaction should have no effect

	repository->Reset();

	ChangeByCreate(*repository);

	CallFuncCheckOtherTransactionsDoNotFail(NoChangeByReadTransaction, *repository);

	// committing an empty transaction should have no effect

	repository->Reset();

	CallFuncCheckOtherTransactionsDoNotFail(NoChangeByEmptyWriteTransaction, *repository);

	CleanupStack::PopAndDestroy(repository);

	// restart session and check values are indeed saved

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

	TInt r;

	TBuf8<40> buf8Value;

	TBuf16<40> buf16Value;

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

	TEST2(r, KErrNone);

	TEST(buf8Value == KString8_InitialValue);

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

	TEST2(r, KErrNone);

	TEST(buf16Value == KString16_InitialValue);

	// final cleanup

	repository->Reset();

	CleanupStack::PopAndDestroy(repository);

	}

/**

@SYMTestCaseID SYSLIB-CENREP-CT-0152

@SYMTestCaseDesc Testing creates in a read write transaction

@SYMTestPriority High

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

@SYMTestExpectedResults The test should not fail with any panics

@SYMPREQ PREQ752

*/

LOCAL_C void CreateValueUsingTransactionL()

	{

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

	TInt r;

	TUint32 errorId;

	CRepository* repository;

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

	// Begin read write transaction

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

	TEST2(r, KErrNone);

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

	TEST2(r, KErrNone);

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

	TEST2(r, KErrNone);

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

	TEST2(r, KErrNone);

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

	TEST2(r, KErrNone);

	// Commit transaction

	r = repository->CommitTransaction(errorId);

	TEST2(r, KErrNone);

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

	TEST2(errorId, 4);

	CleanupStack::PopAndDestroy(repository);

	}

/**

@SYMTestCaseID SYSLIB-CENREP-CT-0153

@SYMTestCaseDesc Testing state and rollback in a transaction

@SYMTestPriority High

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

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

@SYMTestExpectedResults The test should not fail with any panics

@SYMPREQ PREQ752

*/

LOCAL_C void TransactionStateAndRollBackL()

	{

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

	TInt r;

	TUint32 errorId;

	TReal getValue;

	CRepository* repository;

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

	r = TransactionState(repository);

	TEST2(r, ENoTransaction);

	// Try to fail transaction without being in a transaction

	repository->FailTransaction();

	r = TransactionState(repository);

	TEST2(r, ENoTransaction);

	// Begin concurrent read write transaction

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

	TEST2(r, KErrNone);

	r = TransactionState(repository);

	TEST2(r, EReadWriteTransaction);

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

	TEST2(r, KErrNone);

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

	TEST(getValue == KReal2_InitialValue);

	TEST2(r, KErrNone);

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

	repository->FailTransaction();

	r = TransactionState(repository);

	TEST2(r, EReadWriteTransaction | EFailedBit);

	// Commit transaction

	r = repository->CommitTransaction(errorId);

	TEST2(r, KErrAbort);

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

	TEST2(errorId, KUnspecifiedKey);

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

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

	TEST2(r, KErrNotFound);

	r = TransactionState(repository);

	TEST2(r, ENoTransaction);

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

	TEST2(r, KErrNone);

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

	TEST2(r, KErrNone);

	repository->RollbackTransaction();

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

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

	TEST2(r, KErrNotFound);

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

	r = TransactionState(repository);

	TEST2(r, ENoTransaction);

	// Begin read transaction

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

	TEST2(r, KErrNone);

	r = TransactionState(repository);

	TEST2(r, EReadTransaction);

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

	TEST2(r, KErrNone);

	TEST(getValue == KReal1_InitialValue);

	// Fail transaction

	repository->FailTransaction();

	r = TransactionState(repository);

	TEST2(r, EReadTransaction | EFailedBit);

	// Commit transaction

	r = repository->CommitTransaction(errorId);

	TEST2(r, KErrAbort);

	r = TransactionState(repository);

	TEST2(r, ENoTransaction);

	// Begin another read transaction

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

	TEST2(r, KErrNone);

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

	TEST2(r, KErrNone);

	TEST(getValue == KReal1_InitialValue);

	r = TransactionState(repository);

	TEST2(r, EReadTransaction);

	// Perform Create in a ReadTransaction as upgrade has occured

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

	TEST2(r, KErrNone);

	// The state should be updated to be EInReadWriteTransaction

	r = TransactionState(repository);

	TEST2(r, EReadWriteTransaction);

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

	TEST2(r, KErrNone);

	// Commit transaction

	r = repository->CommitTransaction(errorId);

	TEST2(r, KErrNone);

	// Delete KReal2 to reset available test case variables

	r = repository->Delete(KReal2);

	TEST2(r, KErrNone);

	r = TransactionState(repository);

	TEST2(r, ENoTransaction);

	CleanupStack::PopAndDestroy(repository);

	}

LOCAL_C void StartTransactionPanicConditionsL()

	{

	TInt r;

	TUint32 errorId;

	CRepository* repository1;

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

	// Begin read write transaction

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

	TEST2(r, KErrNone);

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

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

	TEST2(r, KErrNone);

	// Commit transaction

	r = repository1->CommitTransaction(errorId);

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(repository1);

	}

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

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(!cleanup)

		return KErrNoMemory;

	TRAPD(err, StartTransactionPanicConditionsL());

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

	TEST2(err, KErrNone);

	delete cleanup;

	__UHEAP_MARKEND;

	return (KErrNone);

	}

/**

@SYMTestCaseID SYSLIB-CENREP-CT-0154

@SYMTestCaseDesc Testing valid panics while using StartTransaction

@SYMTestPriority High

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

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

@SYMPREQ PREQ752

*/

LOCAL_C void TransactionPanicConditionsThread()

	{

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

	TBool jitEnabled = User::JustInTime();

	User::SetJustInTime(EFalse);

	TRequestStatus status;

	_LIT(KName, "Transaction_Panic_Thread");

	RThread thread;

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

	TEST2(rc,KErrNone);

	thread.Logon(status);

	thread.Resume();

	User::WaitForRequest(status);

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

	TEST2(thread.ExitType(), EExitPanic);

	TEST2(thread.ExitReason(), EStartAlreadyInTransaction);

	thread.Close();

	User::SetJustInTime(jitEnabled);

	}

LOCAL_C void CommitTransactionPanicConditionL()

	{

	TInt r;

	TUint32 errorId;

	CRepository* repository1;

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

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

	r = repository1->CommitTransaction(errorId);

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(repository1);

	}

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

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(!cleanup)

		return KErrNoMemory;

	TRAPD(err,CommitTransactionPanicConditionL());

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

	TEST2(err, KErrNone);

	delete cleanup;

	__UHEAP_MARKEND;

	return (KErrNone);

	}

/**

@SYMTestCaseID SYSLIB-CENREP-CT-0155

@SYMTestCaseDesc Testing valid panics while using CommitTransaction

@SYMTestPriority High

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

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

@SYMPREQ PREQ752

*/

LOCAL_C void CommitTransactionPanicConditionsThread()

	{

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

	TBool jitEnabled = User::JustInTime();

	User::SetJustInTime(EFalse);

	TRequestStatus status;

	_LIT(KName, "Commit_Transaction_Panic_Thread");

	RThread thread;

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

	TEST2(rc,KErrNone);

	thread.Logon(status);

	thread.Resume();

	User::WaitForRequest(status);

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

	TEST2(thread.ExitType(), EExitPanic);

	TEST2(thread.ExitReason(), ECommitNotInTransaction);

	thread.Close();

	User::SetJustInTime(jitEnabled);

	}

LOCAL_C void LeaveWithCleanupRollbackTransactionPushL(CRepository& aRepository)

	{

	TInt r = TransactionState(&aRepository);

	TEST2(r, CRepository::EReadWriteTransaction);

	aRepository.CleanupRollbackTransactionPushL();

	// Purposely leave in a transaction...

	User::LeaveNoMemory();

	// this code should never be reached...

	TEST(EFalse);

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

	CleanupStack::Pop();

	}

LOCAL_C void LeaveWithCleanupFailTransactionPushL(CRepository& aRepository)

	{

	TInt r = TransactionState(&aRepository);

	TEST2(r, CRepository::EReadWriteTransaction);

	aRepository.CleanupFailTransactionPushL();

	// Purposely leave in a transaction...

	User::LeaveNoMemory();

	// this code should never be reached...

	TEST(EFalse);

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

	CleanupStack::Pop();

	}

/**

@SYMTestCaseID SYSLIB-CENREP-CT-0156

@SYMTestCaseDesc Testing CleanupRollbackTransactionPushL and CleanupFailTransactionPushL

@SYMTestPriority High

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

	result in CleanupRollbackTransactionPushL being used. Similar operation required for CleanupFailTransactionPushL

@SYMTestExpectedResults The test should not fail with any panics

@SYMPREQ PREQ752

*/

LOCAL_C void CleanupRollBackAndFailTransactionL()

	{

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

	TInt r;

	TUint32 errorId;

	TReal getValue;

	CRepository* repository;

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

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

	TEST2(r, KErrNone);

	repository->CleanupRollbackTransactionPushL();

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

	TEST2(r, KErrNone);

	// Purposely leave in a transaction...

	TRAP(r, LeaveWithCleanupRollbackTransactionPushL(*repository));

	TEST2(r, KErrNoMemory);

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

	r = TransactionState(repository);

	TEST2(r, ENoTransaction);

	// and getting the value KReal2 should result in KErrNotFound

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

	TEST2(r, KErrNotFound);

	CleanupStack::Pop();				// CleanupRollbackTransaction

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

	TEST2(r, KErrNone);

	repository->CleanupFailTransactionPushL();

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

	TEST2(r, KErrNone);

	// Purposely leave in a transaction...

	TRAP(r, LeaveWithCleanupFailTransactionPushL(*repository));

	TEST2(r, KErrNoMemory);

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

	r = TransactionState(repository);

	TEST2(r, EReadWriteTransaction | EFailedBit);

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

	r = repository->CommitTransaction(errorId);

	TEST2(r, KErrAbort);

	// so getting the value KReal2 should result in KErrNotFound

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

	TEST2(r, KErrNotFound);