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

// Contains implementation of CTestCustomPropertyStep class

// 

//

/**

 @file

 @internalTechnology 

*/

// System Includes

#include <bookmarkdatabase.h>

// User Include

#include "TestCustomPropertyStep.h"

/**

Constructor. Sets the test step name

@internalTechnology

@test

*/

CTestCustomPropertyStep::CTestCustomPropertyStep(CTestBookmarksServer& aTestServer) : CTestBookmarksBaseStep(aTestServer)

	{

	//Call base class method to set human readable name for test step

	SetTestStepName(KTestCustomPropertyStep);

	}

/**

Base class pure virtual.

@internalTechnology

@test

@param		None

@return		EPass or EFail indicating the result of the test step.

*/

TVerdict CTestCustomPropertyStep::doTestStepL()

	{

	TPtrC operation;

	TPtrC category;

	TPtrC uniqueId;

	if(!GetStringFromConfig(ConfigSection(), KIniOperation, operation ) ||

	   !GetStringFromConfig(ConfigSection(), KIniCategory, 	category  ) ||

	   !GetStringFromConfig(ConfigSection(), KIniUid,		uniqueId  )

	  )

		{

		ERR_PRINTF4(_L("Problem in reading values from ini.			\

						\nExpected fields are: \n%S\n%S\n%S\n"

					  ),&KIniOperation, &KIniCategory, &KIniUid

				   );

		SetTestStepResult(EFail);

		}

	else

		{

		if(operation.Compare(KRegisterOperation) == KErrNone || operation.Compare(KDeRegisterOperation) == KErrNone)

			{// Register or deregister custom property

			DoRegDeregCustomProperty(operation, category, uniqueId);

			}

		else if(operation.Compare(KSetOperation) == KErrNone || operation.Compare(KGetOperation) == KErrNone)

			{// Set or get custom property

			TRAPD(error, DoSetGetCustomPropertyL(operation, category, uniqueId));

			if(error != KErrNone)

				{

				ERR_PRINTF3(_L("Error occured while doing %S operation: %D"), operation, error);

				SetTestStepResult(EFail);

				}

			}

		else

			{

			ERR_PRINTF2(_L("Invalid operation : %S"), &operation);

			SetTestStepResult(EFail);

			}

		}

	return TestStepResult();

	}	// doTestStepL

/**

Registers or deregisters a custom property

@internalTechnology

@test

@param		Operation to be performed : set/get/register/deregister

@param		Category: db/folder/bookmark

@param		Uid of the custom property

@return		None

*/

void CTestCustomPropertyStep::DoRegDeregCustomProperty(const TPtrC& aOperation, const TPtrC& aCategory, const TPtrC& aUid)

	{

	TInt error = KErrNone;

	TPtrC dataType;

	if(aOperation.Compare(KRegisterOperation) == KErrNone)

		{

		if(!GetStringFromConfig(ConfigSection(), KIniDataType, dataType))

			{

			ERR_PRINTF2(_L("%S should be mentioned in ini for registering a property"), &KIniDataType);

			SetTestStepResult(EFail);

			}

		else

			{

			// Register property

			error = RegisterCustomProperty(aUid, aCategory, dataType);

			}

		}

	else if(aOperation.Compare(KDeRegisterOperation) == KErrNone)

		{

		// Deregister property

		error = DeRegisterCustomProperty(aUid, aCategory);

		}

	// Examine the result

	CheckErrorAndCommit(error);

	}	// DoRegDeregCustomProperty

/**

Resolves and returns the enumeration indicating the custom property type

function

@internalTechnology

@test

@param		Descriptor indicating the data type of the custom property

@return		Bookmark::TPropertyType enumeration indicating the type of property

*/

Bookmark::TPropertyType CTestCustomPropertyStep::GetPropertyType(const TPtrC& aDataType)

	{

	if(aDataType.Compare(KTypeInt) == KErrNone)

		{

		return Bookmark::EDataTypeInt;

		}

	else if(aDataType.Compare(KTypeReal) == KErrNone)

		{

		return Bookmark::EDataTypeReal;

		}

	else if(aDataType.Compare(KTypeDes8) == KErrNone)

		{

		return Bookmark::EDataTypeDes8;

		}

	else

		{

		return Bookmark::EDataTypeDes16;

		}

	}

/**

Registers the custom property

@internalTechnology

@test

@param		Descriptor indicating the UID of the property

@param		Category: db/folder/bookmark

@param		Datatype of the custom property

@return		Error code as a result of the register operation

*/

TInt CTestCustomPropertyStep::RegisterCustomProperty(const TPtrC& aUid, const TPtrC& aCategory, const TPtrC& aDataType)

	{

	// Resolve property type

	Bookmark::TPropertyType propertyType = GetPropertyType(aDataType);

	// Register property

	TInt error = KErrNone;

	if(aCategory.Compare(KDb()) == KErrNone)

		{

		TRAP(error, iBkDb.RegisterDatabasePropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), propertyType));

		}

	else if(aCategory.Compare(KFolder()) == KErrNone)

		{

		TRAP(error, iBkDb.RegisterFolderPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), propertyType));

		}

	else if(aCategory.Compare(KBookmark()) == KErrNone)

		{

		TRAP(error, iBkDb.RegisterBookmarkPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), propertyType));

		}

	else

		{

		ERR_PRINTF2(_L("Invalid category: %S"), aCategory);

		SetTestStepResult(EFail);

		}

	return error;	

	}

/**

De-registers the custom property

@internalTechnology

@test

@param		Descriptor indicating the UID of the property

@param		Category: db/folder/bookmark

@return		Error code as a result of the de-register operation

*/

TInt CTestCustomPropertyStep::DeRegisterCustomProperty(const TPtrC& aUid, const TPtrC& aCategory)

	{

	TInt error = KErrNone;

	if(aCategory.Compare(KDb()) == KErrNone)

		{

		TRAP(error, iBkDb.DeregisterDatabasePropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid))));

		}

	else if(aCategory.Compare(KFolder()) == KErrNone)

		{

		TRAP(error, iBkDb.DeregisterFolderPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid))));

		}

	else if(aCategory.Compare(KBookmark()) == KErrNone)

		{

		TRAP(error, iBkDb.DeregisterBookmarkPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid))));

		}

	else

		{

		ERR_PRINTF2(_L("Invalid category: %S"), aCategory);

		SetTestStepResult(EFail);

		}

	return error;	

	}

/**

Resolves whether to set or get a custom property and calls tha appropriate

function

@internalTechnology

@test

@param		Operation to be performed : set/get/register/deregister

@param		Category: db/folder/bookmark

@param		Uid of the custom property

@return		None

*/

void CTestCustomPropertyStep::DoSetGetCustomPropertyL(const TPtrC& aOperation, const TPtrC& aCategory, const TPtrC& aUid)

	{

	TPtrC dataType;

	if(!GetStringFromConfig(ConfigSection(), KIniDataType, dataType))

		{

		ERR_PRINTF2(_L("%S should be mentioned in ini for setting/getting a property"), &KIniDataType);

		SetTestStepResult(EFail);

		}

	else

		{

		if(aCategory.Compare(KDb) == KErrNone)

			{

			if(aOperation.Compare(KSetOperation) == KErrNone)

				{

				DoSetPropertyL(iBkDb, dataType, aUid);

				}

				else

				{

				DoGetPropertyL(iBkDb, dataType, aUid);

				}

			}

		else

			{

			TPtrC title;

			TPtrC typeOfItem;

			if(!GetStringFromConfig(ConfigSection(), KIniTypeOfItem, typeOfItem	) ||

	   		   !GetStringFromConfig(ConfigSection(), KIniTitle,		 title		)

	   		  )

				{

				ERR_PRINTF3(_L("%S and %S should be mentioned in ini for setting property for bookmark or a folder"), &KIniTypeOfItem, &KIniTitle);

				SetTestStepResult(EFail);

				}

			else

				{

				TInt error = KErrNone;

				RBkNode bkNode;

				if((error = GetBkNode(title, typeOfItem, bkNode)) != KErrNone)

					{

					ERR_PRINTF3(_L("Error occured while opening item %S : %D"), &title, error);

					SetTestStepError(error);

					}

				else

					{// Node opened successfully. Can Set or Get property

					if(aOperation.Compare(KSetOperation) == KErrNone)

						{

						DoSetPropertyL(bkNode, dataType, aUid);

						}

					else

						{

						DoGetPropertyL(bkNode, dataType, aUid);

						}

					bkNode.Close();

					}

				}

			}

		}

	}	// DoSetGetCustomProperty

/**

Template that sets the custom property using SetCustomPropertyL

@internalTechnology

@test

@param		Reference to handle to the DB/Folder/Bookmark

@param		Datatype of the property : int/real/des8/des16

@param		Uid of the custom property

@return		None

*/

template <class RType>

void CTestCustomPropertyStep::DoSetPropertyL(RType &aBkWho, const TPtrC& aDataType, const TPtrC& aUid)

	{

	TPtrC value;

	if(!GetStringFromConfig(ConfigSection(), KIniValue, value))

		{

		ERR_PRINTF2(_L("%S should be mentioned in ini for setting a property"), &KIniValue);

		SetTestStepResult(EFail);

		}

	else

		{

		TInt error = KErrNone;

		INFO_PRINTF2(_L("Setting val for : %U"), CTestBookmarksServer::GetTUint32(aUid));

		if(aDataType.Compare(KTypeInt) == KErrNone)

			{

			TRAP(error, aBkWho.SetCustomPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), CTestBookmarksServer::GetTInt(value)));

			}

		else if(aDataType.Compare(KTypeReal) == KErrNone)

			{

			TRAP(error, aBkWho.SetCustomPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), CTestBookmarksServer::GetTReal(value)));

			}

		else if(aDataType.Compare(KTypeDes8) == KErrNone)

			{

			// Construct 8-bit descriptor

			HBufC8* hBufC8 = HBufC8::NewL(value.Length());

			hBufC8->Des().Copy(value);

			TRAP(error, aBkWho.SetCustomPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), hBufC8->Des()));

			delete hBufC8;

			}

		else if(aDataType.Compare(KTypeDes16) == KErrNone)

			{

			TRAP(error, aBkWho.SetCustomPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), value));

			}

		else

			{

			ERR_PRINTF2(_L("Invalid datatype: %S"), &aDataType);

			SetTestStepResult(EFail);

			}

		// Examine the result

		CheckErrorAndCommit(error);

		}

	}	// DoSetPropertyL

/**

Gets the custom property using GetCustomPropertyL and compares with

expected result

@internalTechnology

@test

@param		Reference to handle to the DB/Folder/Bookmark

@param		Datatype of the property : int/real/des8/des16

@param		Uid of the custom property

@return		None

*/

template <class RType>

void CTestCustomPropertyStep::DoGetPropertyL(RType &aBkWho, const TPtrC& aDataType, const TPtrC& aUid)

	{

	TPtrC expectedValue;

	if(!GetStringFromConfig(ConfigSection(), KIniExpectedValue, expectedValue))

		{

		ERR_PRINTF2(_L("%S should be mentioned in ini for setting a property"), &KIniExpectedValue);

		SetTestStepResult(EFail);

		}

	else

		{

		TInt error = KErrNone;

		TVerdict verdict = EPass;

		// Check the datatype and process accordingly

		if(aDataType.Compare(KTypeInt) == KErrNone)

			{

			TInt retVal = KErrNone;

			TRAP(error, aBkWho.GetCustomPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), retVal));

			if(error == KErrNone)

				{

				verdict = CompareTInts(retVal, CTestBookmarksServer::GetTInt(expectedValue));

				}

			}

		else if(aDataType.Compare(KTypeReal) == KErrNone)

			{

			TReal retVal = KErrNone;

			TRAP(error, aBkWho.GetCustomPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), retVal));

			if(error == KErrNone)

				{

				verdict = CompareTReals(retVal, CTestBookmarksServer::GetTReal(expectedValue));

				}

			}

		else if(aDataType.Compare(KTypeDes8) == KErrNone)

			{

			// Construct 8-bit descriptor

			HBufC8* retVal8 = HBufC8::NewL(Bookmark::KMaxDataLength);

			TPtr8 ptr8 = retVal8->Des();

			TRAP(error, aBkWho.GetCustomPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), ptr8));

			if(error == KErrNone)

				{

				CleanupStack::PushL(retVal8);

				HBufC* retVal = HBufC::NewL(ptr8.Length());

				retVal->Des().Copy(ptr8);

				verdict = CompareStrings(retVal->Des(), expectedValue);

				delete retVal;

				}

			CleanupStack::PopAndDestroy(retVal8);

			}

		else if(aDataType.Compare(KTypeDes16) == KErrNone)

			{

			HBufC* retVal = HBufC::NewL(Bookmark::KMaxDataLength);

			TPtr ptr = retVal->Des();

			TRAP(error, aBkWho.GetCustomPropertyL(TUid::Uid(CTestBookmarksServer::GetTUint32(aUid)), ptr));

			if(error == KErrNone)

				{

				verdict = CompareStrings(ptr, expectedValue);

				}

			delete retVal;

			}

		else

			{

			ERR_PRINTF2(_L("Invalid datatype: %S"), &aDataType);

			SetTestStepResult(EFail);

			}

		// Examine the result

		CheckErrorAndVerdict(error, verdict);

		}

	}	// DoGetPropertyL