// 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>

CRepository*		TheRepository = NULL;

const TUid 			KTestCenRepUid = {0xCCCCCC03};

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

// 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;

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

	{

	delete TheRepository;

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

	}

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

//Test macros and functions

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		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)

		{

		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

	{

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

	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);

	}

/**

 * 

 * @param aValType enum indicating which data type to test

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

 */

	{

	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

	err = SetNewVal(aValType);

	TEST2(err, KErrNone);

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

	err = GetNewVal(aValType, ESetTest, result);

	TEST2(err, KErrNone);

	TEST(result);

	PrintStats(start, end);

	}