// Copyright (c) 2008-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 <centralrepository.h>

#include <e32test.h>

#include <f32file.h>

#include <bautils.h>

#include <hal.h>

RTest 				TheTest(_L("t_cenrep_perf test"));

CRepository*		TheRepository = NULL;

const TUid 			KTestCenRepUid = {0xCCCCCC03};

_LIT(KFileName, "c:\\private\\10202be9\\persists\\cccccc03.cre");

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

// Shared test data 

enum TValType {EIntVal, ERealVal, EBinaryVal, EStringVal, EMetaVal};

enum TTestType {ESetTest, ECreateTest, EFindEqTest, EFindNeqTest, EResetTest};

// int

const TUint32 KIntKey = 42011136ul;

const TUint32 KNewIntKey = 2374040320ul;

const TUint32 KNewIntKey2 = 2374040576ul;

const TInt KOldIntVal = 10;

const TInt KNewIntVal = KOldIntVal + 1;

const TUint32 KIntMeta = 0;

// real

const TUint32 KRealKey = 2374041088ul;

const TUint32 KNewRealKey = 2374041344ul;

const TReal KOldRealVal = 0.1;

const TReal KNewRealVal = KOldRealVal + 1.0;

// binary

const TUint32 KBinKey = 42141952ul;

const TUint32 KNewBinKey = 2374040832ul;

_LIT8(KOldBinVal, "\x44\x00\x69\x00\x61\x00\x6c\x00\x4f\x00\x75\x00\x74\x00\x49\x00\x53\x00\x50\x00");

_LIT8(KNewBinVal, "\x44\x00\x69\x00\x61\x00\x6c\x00\x4f\x00\x75\x00\x74\x00\x49\x00\x53\x00\x50\x01");

// string

const TUint32 KStrKey = 2374041600ul;

const TUint32 KNewStrKey = 2374041856ul;

_LIT(KOldStrVal, "hello");

_LIT(KNewStrVal, "goodbye");

// FindL range data

const TUint32 KFindPartialKey = 0x08440000ul;

const TUint32 KFindMask = 0x0FFF0000ul;

const TInt KFindKeyCount = 15;

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

TInt DeleteCreFile()

	{

	RFs fs;

	fs.Connect();

	TInt err = fs.Delete(KFileName);

	fs.Close();

	// it's fine if the file or path wasn't found as there's nothing to 

	// delete so return KErrNone

	return (err == KErrNotFound || err == KErrPathNotFound) ? KErrNone : err;

	}

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

void DestroyTestEnv()

	{

	delete TheRepository;

	// delete the CRE file to clear out any changes made during the test

	DeleteCreFile(); 

	}

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

//Test macros and functions

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		DestroyTestEnv();

		RDebug::Print(_L("*** Test failure. Boolean expression evaluates to false.\r\n"));

		TheTest(EFalse, aLine);

		}

	}

void Check2(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		DestroyTestEnv();

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

		TheTest(EFalse, aLine);

		}

	}

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

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

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

// leaves if it can't successfully delete the cre file if it exists

void CreateTestEnvL()

	{

	// delete the CRE file to clear out any changes leftover from previous test runs

	User::LeaveIfError(DeleteCreFile());

	TRAPD(err, TheRepository = CRepository::NewL(KTestCenRepUid));

	TEST2(err, KErrNone);

	}

//Prints aTicks parameter (converted to us)

void PrintStats(TUint32 aStartTicks, TUint32 aEndTicks)

	{

	static TInt freq = 0;

	if(freq == 0)

		{

		TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);

		}

	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;

	if(diffTicks < 0)

		{

		diffTicks = KMaxTUint32 + diffTicks + 1;

		}

	const TInt KMicroSecIn1Sec = 1000000;

	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;

	TheTest.Printf(_L("####Execution time: %d us\r\n"), us);

	}

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

// Utility functions containing code common to multiple test cases

/**

 * Common code for calling Get() with old values

 * 

 * @param aValType enum indicating which data type to test

 * 	(EIntVal, ERealVal, EBinaryVal, EStringVal or EMetaVal-- any other value will return KErrArgument).

 * @param aResult bool indicating whether the comparison was successful

 * @return err code from Get() 

 */

TInt GetOldVal(TValType aValType, TBool& aResult)

	{

	TInt intVal(0);

	TReal realVal(0.0);

	TBuf8<100> binVal;

	TBuf16<100> strVal;

	TUint32 metaVal(0);

	TInt err(KErrNone);

	switch (aValType)

		{

		case EIntVal:

			err = TheRepository->Get(KIntKey, intVal);

			aResult = (intVal == KOldIntVal); 

			break;

		case ERealVal:

			err = TheRepository->Get(KRealKey, realVal);

			aResult = (realVal == KOldRealVal); 

			break;

		case EBinaryVal:

			err = TheRepository->Get(KBinKey, binVal);

			aResult = (binVal == KOldBinVal); 

			break;

		case EStringVal:

			err = TheRepository->Get(KStrKey, strVal);

			aResult = (strVal == KOldStrVal); 

			break;

		case EMetaVal:

			err = TheRepository->GetMeta(KIntKey, metaVal);

			aResult = (metaVal == KIntMeta);

			break;

		default:

			err = KErrArgument;

			break;

		}

	return err;

	}

/**

 * Common code for calling Get() with new values

 * 

 * @param aValType enum indicating which data type to test

 * 	(EIntVal, ERealVal, EBinaryVal or EStringVal -- any other value will return KErrArgument).

 * @param aTestType enum defining whether Set() or Create() is being tested

 * 	(ESetTest or ECreateTest -- anything else will return KErrArgument). 

 * @param aResult bool indicating whether the comparison was successful

 * @return err code from Get() 

 */

TInt GetNewVal(TValType aValType, TTestType aTestType, TBool& aResult)

	{

	// check correct test type

	if (aTestType != ECreateTest && aTestType != ESetTest)

		{

		return KErrArgument;

		}

	TInt intVal(0);

	TReal realVal(0.0);

	TBuf8<100> binVal;

	TBuf16<100> strVal;

	TInt err(KErrNone);

	switch (aValType)

		{

		case EIntVal:

			err = TheRepository->Get(

					(aTestType == ECreateTest ? KNewIntKey : KIntKey), intVal);

			aResult = (intVal == KNewIntVal); 

			break;

		case ERealVal:

			err = TheRepository->Get(

					(aTestType == ECreateTest ? KNewRealKey : KRealKey), realVal);

			aResult = (realVal == KNewRealVal); 

			break;

		case EBinaryVal:

			err = TheRepository->Get(

					(aTestType == ECreateTest ? KNewBinKey : KBinKey), binVal);

			aResult = (binVal == KNewBinVal); 

			break;

		case EStringVal:

			err = TheRepository->Get(

					(aTestType == ECreateTest ? KNewStrKey : KStrKey), strVal);

			aResult = (strVal == KNewStrVal); 

			break;

		case EMetaVal:

			// no meta testing on new setting so fall through

		default:

			err = KErrNotFound;

			break;

		}

	return err;

	}

/**

 * Common code for calling Set()

 * 

 * @param aValType enum indicating which data type to test

 * 	(EIntVal, ERealVal, EBinaryVal or EStringVal -- any other value will return KErrArgument).

 * @return err code from Set() 

 */

TInt SetNewVal(TValType aValType)

	{

	TInt err(KErrNone);

	switch (aValType)

		{

		case EIntVal:

			err = TheRepository->Set(KIntKey, KNewIntVal);

			break;

		case ERealVal:

			err = TheRepository->Set(KRealKey, KNewRealVal);

			break;

		case EBinaryVal:

			err = TheRepository->Set(KBinKey, KNewBinVal);

			break;

		case EStringVal:

			err = TheRepository->Set(KStrKey, KNewStrVal);

			break;

		case EMetaVal:

			// no meta testing on new setting so fall through

		default:

			err = KErrArgument;

			break;

		}

	return err;

	}

/**

 * Common code for calling Create()

 * 

 * @param aValType enum indicating which data type to test

 * 	(EIntVal, ERealVal, EBinaryVal or EStringVal -- any other value will return KErrArgument).

  * @return err code from Create() 

 */

TInt CreateNewSetting(TValType aValType)

	{

	TInt err(KErrNone);

	switch (aValType)

		{

		case EIntVal:

			err = TheRepository->Create(KNewIntKey, KNewIntVal);

			break;

		case ERealVal:

			err = TheRepository->Create(KNewRealKey, KNewRealVal);

			break;

		case EBinaryVal:

			err = TheRepository->Create(KNewBinKey, KNewBinVal);

			break;

		case EStringVal:

			err = TheRepository->Create(KNewStrKey, KNewStrVal);

			break;

		case EMetaVal:

			// no meta testing on new setting so fall through

		default:

			err = KErrArgument;

			break;

		}

	return err;

	}

/**

 * Common code for calling Reset()

 * 

 * @param aValType enum indicating which data type to test

 * 	(EIntVal, ERealVal, EBinaryVal or EStringVal -- any other value will return KErrArgument).

  * @return err code from Reset() 

 */

TInt ResetSetting(TValType aValType)

	{

	TInt err(KErrNone);

	switch (aValType)

		{

		case EIntVal:

			err = TheRepository->Reset(KIntKey);

			break;

		case ERealVal:

			err = TheRepository->Reset(KRealKey);

			break;

		case EBinaryVal:

			err = TheRepository->Reset(KBinKey);

			break;

		case EStringVal:

			err = TheRepository->Reset(KStrKey);

			break;

		case EMetaVal:

			// no meta testing on new setting so fall through

		default:

			err = KErrArgument;

			break;

		}

	return err;

	}

/**

 * Common code for calling FindL()

 * 

 * @param aStart Out parameter for start timer value

 * @param aEnd Out parameter for end timer value

 * @param aFound Out parameter for number of settings found

 * @return err code from FindL()

 */

TInt FindRangeL(TInt& aStart, TInt& aEnd, TInt& aFound)

	{

	RArray<TUint32> keys;

	CleanupClosePushL(keys);

	aStart = User::FastCounter();

	TInt err = TheRepository->FindL(KFindPartialKey, KFindMask, keys);

	aEnd = User::FastCounter();

	aFound = keys.Count();

	CleanupStack::PopAndDestroy(&keys);

	return err;

	}

/**

 * Common code for performing all the Get() tests

 * 

 * @param aValType enum indicating which data type to test

 * 	(EIntVal, ERealVal, EBinaryVal, EStringVal or EMetaVal -- any other value will fail with KErrArgument).

 * @param aUseTransaction bool instructing whether to use a read-mode transaction or not

 */

void DoGetTest(TValType aValType, TBool aUseTransaction = EFalse)

	{

	TInt err(KErrNone);

	TInt result(EFalse);

	TUint32 keyInfo(0);

	TUint32 start = User::FastCounter();

	// start transaction, if required

	err = aUseTransaction ? TheRepository->StartTransaction(CRepository::EReadTransaction) : err;

	TEST2(err, KErrNone);

	err = GetOldVal(aValType, result);

	TEST2(err, KErrNone);

	// end transaction, if required

	err = aUseTransaction ? TheRepository->CommitTransaction(keyInfo) : err;

	TEST2(err, KErrNone);

	TUint32 end = User::FastCounter();

	TEST(result);

	PrintStats(start, end);

	}

/**

 * Common code for performing the Set() and Reset() tests for all datatypes

 * 

 * @param aValType enum indicating which data type to test

 * 	(EIntVal, ERealVal, EBinaryVal or EStringVal -- any other value will fail with KErrArgument).

 * @param aTestType enum defining whether Set() or Reset() should be timed

 */

void DoSetResetTest(TValType aValType, TTestType aTestType)

	{

	TInt err(KErrNone);

	TInt result(EFalse);

	// Check we get the old expected value

	err = GetOldVal(aValType, result);

	TEST2(err, KErrNone);

	TEST(result);

	TUint32 start(0);

	TUint32 end(0);

	// Set the new value

	start = aTestType == ESetTest ? User::FastCounter() : start;

	err = SetNewVal(aValType);

	end = aTestType == ESetTest ? User::FastCounter() : end;

	TEST2(err, KErrNone);

	// Test we get the new value to check it's worked

	err = GetNewVal(aValType, ESetTest, result);

	TEST2(err, KErrNone);

	TEST(result);

	// Restore the old value

	start = aTestType == EResetTest ? User::FastCounter() : start;

	err = ResetSetting(aValType);

	end = aTestType == EResetTest ? User::FastCounter() : end;

	TEST2(err, KErrNone);

	// Check reset's worked

	err = GetOldVal(aValType, result);

	TEST2(err, KErrNone);

	TEST(result);

	PrintStats(start, end);

	}

/**

 * Common code for performing all the Create() tests

 * 

 * @param aValType enum indicating which data type to test

 * 	(EIntVal, ERealVal, EBinaryVal, EStringVal, EMetaVal -- any other value will fail with KErrArgument).

 */

void DoCreateTest(TValType aValType)

	{

	TInt err(KErrNone);

	TInt result(EFalse);

	TUint32 start(0);

	TUint32 end(0);

	// Create the new setting

	start = User::FastCounter();

	err = CreateNewSetting(aValType);

	end = User::FastCounter();

	TEST2(err, KErrNone);

	// Test we get the right value from the new setting to check it's worked

	err = GetNewVal(aValType, ECreateTest, result);

	TEST2(err, KErrNone);

	TEST(result);

	PrintStats(start, end);

	}

/**

 * Common code for performing all the FindEqL() and FindNeqL() tests

 * 

 * @param aValType enum indicating which data type to test

 * 	(EIntVal, ERealVal, EBinaryVal, EStringVal, EMetaVal -- any other value will fail with KErrArgument).

 * @param aTestType enum defining whether FindEqL() or FindNeqL() should be timed

 * 	(EFindEqTest or EFindNeqTest -- anything else will leave with KErrArgument). 

 */

void DoFindEqNeqTestL(TValType aValType, TTestType aTestType)

	{

	const TUint32 KPartialKey(0x8D800000);

	const TUint32 KMask(0xFFF00000);

	const TInt KFindNum(1); 

	const TInt KNotFindNum(15);

	const TInt KIntFindVal(9999);

	const TReal KRealFindVal(999.9);

	_LIT8(KBinFindVal, "\xab\xcd\x99\x99");

	_LIT(KStrFindVal, "abcd9999");

	RArray<TUint32> results;

	CleanupClosePushL(results);

	TInt expectedCount(0);

	switch(aTestType)

		{

		case EFindEqTest:

			expectedCount = KFindNum;

			break;

		case EFindNeqTest:

			expectedCount = KNotFindNum;

			break;

		default:

			// wrong test type passed in

			User::Leave(KErrArgument);

		}

	TInt err(KErrNone);

	TUint32 start = User::FastCounter();

	switch (aValType)

		{

		case EIntVal:

			err = (aTestType == EFindEqTest) ?

					TheRepository->FindEqL(KPartialKey, KMask, KIntFindVal, results) :

					TheRepository->FindNeqL(KPartialKey, KMask, KIntFindVal, results);

			break;

		case ERealVal:

			err = (aTestType == EFindEqTest) ?

					TheRepository->FindEqL(KPartialKey, KMask, KRealFindVal, results) :

					TheRepository->FindNeqL(KPartialKey, KMask, KRealFindVal, results);

			break;

		case EBinaryVal:

			err = (aTestType == EFindEqTest) ?

					TheRepository->FindEqL(KPartialKey, KMask, KBinFindVal, results) :

					TheRepository->FindNeqL(KPartialKey, KMask, KBinFindVal, results);

			break;

		case EStringVal:

			err = (aTestType == EFindEqTest) ?

					TheRepository->FindEqL(KPartialKey, KMask, KStrFindVal, results) :

					TheRepository->FindNeqL(KPartialKey, KMask, KStrFindVal, results);

			break;

		case EMetaVal:

			// no meta testing on new setting so fall through

		default:

			err = KErrArgument;

			break;

		}

	TUint32 end = User::FastCounter();

	// Test there was no error and that we found the expected number

	TEST2(err, KErrNone);

	TEST(results.Count() == expectedCount);

	CleanupStack::PopAndDestroy(&results);

	PrintStats(start, end);

	}

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

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

// TEST CASES

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-UT-4047

@SYMTestCaseDesc		CRepository::Get(TUint32 aKey, TInt& aValue) - performance test

						The test measures the time needed for retrieving of a single integer setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Get(TUint32 aKey, TInt& aValue) - performance test

@SYMTestExpectedResults Test must not fail

@SYMDEF					DEF128986

*/

void GetIntTest()

	{

	DoGetTest(EIntVal);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4087

@SYMTestCaseDesc		CRepository::Get(TUint32 aKey, TReal& aValue) - performance test

						The test measures the time needed for retrieving of a single real setting,

						witht the Get() wrapped in a read-mode transaction.

@SYMTestPriority		High

@SYMTestActions			CRepository::Get(TUint32 aKey, TReal& aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void GetRealTest()

	{

	DoGetTest(ERealVal, ETrue);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-UT-4048

@SYMTestCaseDesc		CRepository::Get(TUint32 aKey, TDes8& aValue) - performance test

						The test measures the time needed for retrieving of a single 8-bit string setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Get(TUint32 aKey, TDes8& aValue) - performance test

@SYMTestExpectedResults Test must not fail

@SYMDEF					DEF128986

*/

void GetBinaryTest()

	{

	DoGetTest(EBinaryVal);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4088

@SYMTestCaseDesc		CRepository::Get(TUint32 aKey, TDes8& aValue) - performance test

						The test measures the time needed for retrieving of a single 8-bit string setting,

						with the Get() wrapped in a read-mode transaction.

@SYMTestPriority		High

@SYMTestActions			CRepository::Get(TUint32 aKey, TDes8& aValue)

						CRepository::StartTransaction(TTransactionMode aMode)

						CRepository::CommitTransaction(TUint32 &aKeyInfo)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void GetBinaryInTransactionTest()

	{

	DoGetTest(EBinaryVal, ETrue);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4089

@SYMTestCaseDesc		CRepository::Get(TUint32 aKey, TDesC16& aValue) - performance test

						The test measures the time needed for retrieving of a single 16-bit string setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Get(TUint32 aKey, TDesC16& aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void GetStringTest()

	{

	DoGetTest(EStringVal, ETrue);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4090

@SYMTestCaseDesc		CRepository::GetMeta(TUint32 aKey, TUint32& aMeta) - performance test

						The test measures the time needed for retrieving metadata for a single setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::GetMeta(TUint32 aKey, TUint32& aMeta)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void GetMetaTest()

	{

	DoGetTest(EMetaVal, ETrue);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4091

@SYMTestCaseDesc		CRepository::Set(TUint32 aKey, TInt aValue) - performance test

						The test measures the time needed for setting a single integer setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Set(TUint32 aKey, TInt aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void SetIntTest()

	{

	DoSetResetTest(EIntVal, ESetTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4092

@SYMTestCaseDesc		CRepository::Set(TUint32 aKey, TReal aValue) - performance test

						The test measures the time needed for setting a single real setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Set(TUint32 aKey, TReal aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void SetRealTest()

	{

	DoSetResetTest(ERealVal, ESetTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4093

@SYMTestCaseDesc		CRepository::Set(TUint32 aKey, TDes8& aValue) - performance test

						The test measures the time needed for setting a single 8-bit string setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Set(TUint32 aKey, TDes8& aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void SetBinaryTest()

	{

	DoSetResetTest(EBinaryVal, ESetTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4094

@SYMTestCaseDesc		CRepository::Set(TUint32 aKey, TDesC16& aValue) - performance test

						The test measures the time needed for setting a single 16-bit string setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Set(TUint32 aKey, TDesC16& aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void SetStringTest()

	{

	DoSetResetTest(EStringVal, ESetTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4095

@SYMTestCaseDesc		CRepository::Create(TUint32 aKey, TInt aValue) - performance test

						The test measures the time needed for creating a new single integer setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Create(TUint32 aKey, TInt aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void CreateIntTest()

	{

	DoCreateTest(EIntVal);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4096

@SYMTestCaseDesc		CRepository::Create(TUint32 aKey, TReal aValue) - performance test

						The test measures the time needed for creating a new single real setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Create(TUint32 aKey, TReal aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void CreateRealTest()

	{

	DoCreateTest(ERealVal);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4097

@SYMTestCaseDesc		CRepository::Create(TUint32 aKey, TDesC8& aValue) - performance test

						The test measures the time needed for creating a new single 8-bit string setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Create(TUint32 aKey, TDesC8& aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void CreateBinaryTest()

	{

	DoCreateTest(EBinaryVal);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4098

@SYMTestCaseDesc		CRepository::Create(TUint32 aKey, TDesC16& aValue) - performance test

						The test measures the time needed for creating a new single 16-bit string setting.

@SYMTestPriority		High

@SYMTestActions			CRepository::Create(TUint32 aKey, TDesC16& aValue)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void CreateStringTest()

	{

	DoCreateTest(EStringVal);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-UT-4049

@SYMTestCaseDesc		CRepository::FindL(TUint32 aPartialKey, TUint32 aMask, RArray<TUint32>& aFoundKeys) - performance test

						The test measures the time needed for retrieving of an array of keys matching the function arguments.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindL(TUint32 aPartialKey, TUint32 aMask, RArray<TUint32>& aFoundKeys)

@SYMTestExpectedResults Test must not fail

@SYMDEF					DEF128986

*/

void FindTestL()

	{

	TInt start(0);

	TInt end(0);

	TInt found(0);

	TInt err = FindRangeL(start, end, found);

	TEST2(err, KErrNone);

	TEST2(found, KFindKeyCount);

	PrintStats(start, end);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4099

@SYMTestCaseDesc		CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask, TInt aValue, RArray< TUint32 > &aFoundKeys) - performance test

						The test measures the time to find an int setting in an "equals" search on a range.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask, TInt aValue, RArray< TUint32 > &aFoundKeys)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void FindEqIntTestL()

	{

	DoFindEqNeqTestL(EIntVal, EFindEqTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4100

@SYMTestCaseDesc		CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask, TReal aValue, RArray< TUint32 > &aFoundKeys) - performance test

						The test measures the time to find a real setting in an "equals" search on a range.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask, TReal aValue, RArray< TUint32 > &aFoundKeys)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void FindEqRealTestL()

	{

	DoFindEqNeqTestL(ERealVal, EFindEqTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4101

@SYMTestCaseDesc		CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask, TDesC8& aValue, RArray< TUint32 > &aFoundKeys) - performance test

						The test measures the time to find an 8-bit string setting in an "equals" search on a range.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask, TDesC8& aValue, RArray< TUint32 > &aFoundKeys)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void FindEqBinaryTestL()

	{

	DoFindEqNeqTestL(EBinaryVal, EFindEqTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4102

@SYMTestCaseDesc		CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask, TDesC16& aValue, RArray< TUint32 > &aFoundKeys) - performance test

						The test measures the time to find an 16-bit string setting in an "equals" search on a range.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindEqL(TUint32 aPartialKey, TUint32 aMask, TDesC16& aValue, RArray< TUint32 > &aFoundKeys)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void FindEqStringTestL()

	{

	DoFindEqNeqTestL(EStringVal, EFindEqTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4103

@SYMTestCaseDesc		CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask, TInt aValue, RArray< TUint32 > &aFoundKeys) - performance test

						The test measures the time to find an int setting in an "not equals" search on a range.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask, TInt aValue, RArray< TUint32 > &aFoundKeys)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void FindNeqIntTestL()

	{

	DoFindEqNeqTestL(EIntVal, EFindNeqTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4104

@SYMTestCaseDesc		CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask, TReal aValue, RArray< TUint32 > &aFoundKeys) - performance test

						The test measures the time to find a real setting in an "not equals" search on a range.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask, TReal aValue, RArray< TUint32 > &aFoundKeys)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void FindNeqRealTestL()

	{

	DoFindEqNeqTestL(ERealVal, EFindNeqTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4105

@SYMTestCaseDesc		CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask, TDesC8& aValue, RArray< TUint32 > &aFoundKeys) - performance test

						The test measures the time to find an 8-bit string setting in an "not equals" search on a range.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask, TDesC8& aValue, RArray< TUint32 > &aFoundKeys)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void FindNeqBinaryTestL()

	{

	DoFindEqNeqTestL(EBinaryVal, EFindNeqTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4106

@SYMTestCaseDesc		CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask, TDesC16& aValue, RArray< TUint32 > &aFoundKeys) - performance test

						The test measures the time to find an 16-bit string setting in an "not equals" search on a range.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindNeqL(TUint32 aPartialKey, TUint32 aMask, TDesC16& aValue, RArray< TUint32 > &aFoundKeys)

@SYMTestExpectedResults Test must not fail

@SYMPREQ				PREQ2505

@SYMREQ					REQ13142

*/

void FindNeqStringTestL()

	{

	DoFindEqNeqTestL(EStringVal, EFindNeqTest);

	}

/**

@SYMTestCaseID			PDS-CENTRALREPOSITORY-CT-4107

@SYMTestCaseDesc		Performance test that measures the time taken to retrieve data to rebuild a table of ints with 22 rows 

						and 8 columns, using successive calls of Find() with subsequent calls to Get for each key retrieved.

@SYMTestPriority		High

@SYMTestActions			CRepository::FindL(TUint32 aPartialKey, TUint32 aMask, RArray<TUint32>& aFoundKeys)

						CRepository::Get(TUint32 aPartialKey, TUint32 aMask, RArray<TUint32>& aFoundKeys)