/*

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Performs decision filter, record and database tests

*

*/

/**

 @file

 @test

*/

#include "tupsdbstep.h"

#include <test/testexecutelog.h>

using namespace UserPromptService;

CUpsDbStepUnitTest::CUpsDbStepUnitTest()

/**

	Constructer

 */

	{

	iComparison = EEqual;

	iCancel = EFalse;	

	}

CUpsDbStepUnitTest::~CUpsDbStepUnitTest()

/**

	Destructor

 */

	{

	iFs.Close();

	iFileWriteStream.Close();

	iFileReadStream.Close();

	delete iWaiter;

	delete iScheduler;

	}

TVerdict CUpsDbStepUnitTest::doTestStepPreambleL()

/**

	This function is called at the beginning of the test step. First reads the operation type

	and converts it to a proper enumaration value (TUpsDbUnitTest). Then gets the specified 

	database location. The test fails if the database location can not be found, except

	the unit tests of the decision record and filter objects.

 */

	{

	iScheduler = new(ELeave) CActiveScheduler;

	CActiveScheduler::Install(iScheduler);

	iWaiter = new(ELeave)CActiveWaiter(Logger());

	iLog = EFalse;

	TPtrC opType;

	if(EFalse == GetStringFromConfig(ConfigSection(),KOpType,opType))

		{

		ERR_PRINTF2(_L("Failed to read '%S' key of configuration"),&KOpType);

		SetTestStepResult(EFail);

		}

	if(!opType.CompareF(KInsertRecord))

		{

		iOpType = EInsertRecord;

		}

	else if(!opType.CompareF(KDeleteRecord))

		{

		iOpType = EDeleteRecord;

		}

	else if(!opType.CompareF(KSingleLookup))

		{

		iOpType = ESingleLookup;

		}

	else if(!opType.CompareF(KMultipleLookup))

		{

		iOpType = EMultipleLookup;

		}

	else if(!opType.CompareF(KVerifyRecord))

		{

		iOpType = EVerifyRecord;

		}

	else if(!opType.CompareF(KCreateDatabase))

		{

		iOpType = ECreateDatabase;

		}

	else if(!opType.CompareF(KDeleteDatabase))

		{

		iOpType = EDeleteDatabase;

		}

	else if(!opType.CompareF(KCreateFilterSingleCall))

		{

		iOpType = ECreateFilterSingleCall;

		}

	else if(!opType.CompareF(KCreateFilterMultipleCalls))

		{

		iOpType = ECreateFilterMultipleCalls;

		}

	else if(!opType.CompareF(KCreateDecision))

		{

		iOpType = ECreateDecision;

		}

	else if(!opType.CompareF(KFillTable))

		{

		iOpType = EFillTable;

		}

	else if(!opType.CompareF(KAllFingerprints))

		{

		iOpType = EAllFingerprints;

		}

	else if(!opType.CompareF(KCompactDatabase))

		{

		iOpType = ECompact;

		}

	else if(!opType.CompareF(KUpdateRecord))

		{

		iOpType = EUpdate;

		}

	else

		{

		iOpType = ENotSupported;

		}

	if(EFalse == GetStringFromConfig(ConfigSection(),KDbLocation,iDbLocation))

		{

		if((iOpType != ECreateFilterSingleCall) && (iOpType != ECreateDecision) && 

		   (iOpType != ECreateFilterMultipleCalls) && (iOpType != ENotSupported))

			{

			ERR_PRINTF2(_L("Failed to read '%S' key of configuration"),&KDbLocation);

			SetTestStepResult(EFail);

			User::Leave(KErrNotFound);

			}

		}

	GetBoolFromConfig(ConfigSection(), KOOMCondition,iOOMCondition);

	User::LeaveIfError(iFs.Connect());

	User::LeaveIfError(iFs.CreatePrivatePath(EDriveC));			

	return TestStepResult();

	}

TVerdict CUpsDbStepUnitTest::doTestStepL()

/**

	Calls actual test step or OOM test

 */

	{

	if (!iOOMCondition)

		{

		 doTestL(); 

		}

	else

		{

 		return doOOMTestL();

	    }	

   	 return TestStepResult();

	}

TVerdict CUpsDbStepUnitTest::doTestL()

/**

	Perform the actual test steps. Unit tests for all provided database operations

	and creation of both filter and decision record objects.

 */

	{

	//Define required objects

	CDecisionDbW    *upsDb  = NULL;

	CDecisionRecord *record = NULL;

	CDecisionFilter *filter = NULL;

	CleanupClosePushL(iFingerprint);

	CleanupClosePushL(iClientEntity);

	switch(iOpType)

		{

		case ECreateDatabase:

			{

			//Make sure the database file does not exist

			iFs.Delete(iDbLocation);

			//Create the database

			upsDb = CreateDatabaseLC(iDbLocation, iFs);

			//Disconnect

			CleanupStack::PopAndDestroy(upsDb);

			break;

			}

		case EDeleteDatabase:

			{

			//Connect to the database

			upsDb = CDecisionDbW::NewL(iDbLocation, iFs);

			CleanupStack::PushL(upsDb);

			//Delete all records and database

			RemoveAllDecisionsL(*upsDb, iFs);

			//Disconnect

			CleanupStack::PopAndDestroy(upsDb);

			break;

			}

		case ECreateFilterSingleCall:

			{

			//Read the decision values from the config file

			ReadDecisionFieldsL(EFalse);

			TPtrC strExpectedResult;

			if(EFalse == GetStringFromConfig(ConfigSection(),KExpectedResult,strExpectedResult))

				{

				ERR_PRINTF1(_L("Expected result is missing!"));

				SetTestStepResult(EFail);

				break;

				}

			TInt expectedResult = ConvertNumber(strExpectedResult);

			//First method is to create a filter with single function call	

			TRAPD(error,filter = CDecisionFilter::NewL(TUid::Uid(iClientSid),TUid::Uid(iEvaluatorId),TUid::Uid(iServiceId),TUid::Uid(iServerSid),iFingerprint,iClientEntity,iMajorPolicyVersion));	

			if(error != expectedResult)

				{

				ERR_PRINTF3(_L("In the single call method, the result (%d) is different from the expected result (%d)"), error, expectedResult);

				SetTestStepResult(EFail);

				}

			if(error == KErrNone)

				{

				INFO_PRINTF1(_L("Successful to create a decision filter using the single call method"));

				delete filter;

				}

			else

				{

				INFO_PRINTF1(_L("Failed to create a decision filter using the single call method"));

				}

			break;

			}

		case ECreateFilterMultipleCalls:

			{

			//Read the decision values from the config file

			ReadDecisionFieldsL(EFalse);

			TPtrC strExpectedResult;

			if(EFalse == GetStringFromConfig(ConfigSection(),KExpectedResult,strExpectedResult))

				{

				ERR_PRINTF1(_L("Expected result is missing!"));

				SetTestStepResult(EFail);

				break;

				}

			TInt expectedResult = ConvertNumber(strExpectedResult);

			//Second method is to create an empty filter and then set provided fields

			TRAPD(error,filter = CreateFilterL(iSetFlag,iClientSid,iEvaluatorId,iServiceId,iServerSid,iFingerprint,iClientEntity,iMajorPolicyVersion,iRecordId,iDescription,iResult,iEvaluatorInfo,iComparison));		

				if(error != expectedResult)

				{

				ERR_PRINTF3(_L("In the multiple calls method, the result (%d) is different from the expected result (%d)"), error, expectedResult);

				SetTestStepResult(EFail);

				}

			if(error == KErrNone)

				{

				INFO_PRINTF1(_L("Successful to create a decision filter using the multiple calls method"));

				delete filter;

				}

			else

				{

				INFO_PRINTF1(_L("Failed to create a decision filter using the multiple calls method"));

				}

			break;

			}

		case ECreateDecision:

			{

			//Read the decision values from the config file

			ReadDecisionFieldsL(EFalse);

			TPtrC strExpectedResult;

			if(EFalse == GetStringFromConfig(ConfigSection(),KExpectedResult,strExpectedResult))

				{

				ERR_PRINTF1(_L("Expected result is missing!"));

				SetTestStepResult(EFail);

				break;

				}

			TInt expectedResult = ConvertNumber(strExpectedResult);

			TRAPD(error,record = CreateRecordL(iClientSid,iEvaluatorId,iServiceId,iServerSid,iFingerprint,iClientEntity,iDescription,iResult,iMajorPolicyVersion,iEvaluatorInfo,iRecordId));

			if(error != expectedResult)

				{

				ERR_PRINTF3(_L("The result (%d) is different from the expected result (%d)"), error, expectedResult);

				SetTestStepResult(EFail);

				}

				if(error == KErrNone)

				{

				INFO_PRINTF1(_L("Successful to create a decision record"));

				delete record;

				}

			else

				{

				INFO_PRINTF1(_L("Failed to create a decision record"));

				}

			break;

			}

		case EInsertRecord:

			{

			//Read the decision values from the config file

			ReadDecisionFieldsL(ETrue);

			//ClientSid,EvaluatorId,ServiceId,ServerSid and Fingerprint must be provided

			if((iSetFlag & (KSetClientSid|KSetEvaluatorId|KSetServiceId|KSetServerSid|KSetFingerprint))!=

			   (KSetClientSid|KSetEvaluatorId|KSetServiceId|KSetServerSid|KSetFingerprint))

				{

				SetTestStepResult(EFail);

				break;

				}

			//Create decision record

			record = CreateRecordL(iClientSid,iEvaluatorId,iServiceId,iServerSid,iFingerprint,iClientEntity,iDescription,iResult,iMajorPolicyVersion,iEvaluatorInfo,iRecordId);

			CleanupStack::PushL(record);

			//Connect to the database

			upsDb = CDecisionDbW::NewL(iDbLocation,iFs);

			CleanupStack::PushL(upsDb);

			//Insert the decision

			InsertRecordL(*upsDb, *record);

			//Disconnect and destroy objects

			CleanupStack::PopAndDestroy(2,record);

			break;

			}

		case EDeleteRecord:

			{

			//Read the decision values from the config file

			ReadDecisionFieldsL(ETrue);

			if(!iSetFlag)

				{

				ERR_PRINTF1(_L("A filter key must be supplied at least!"));

				SetTestStepResult(EFail);

				break;

				}

			//Create filter

			filter = CreateFilterLC(iSetFlag,iClientSid,iEvaluatorId,iServiceId,iServerSid,iFingerprint,iClientEntity,iMajorPolicyVersion,iRecordId,iDescription,iResult,iEvaluatorInfo,iComparison);

			//Connect to the database

			upsDb = CDecisionDbW::NewLC(iDbLocation,iFs);	

			//Delete the decision

			RemoveDecisionsL(*upsDb, *filter);

			CleanupStack::PopAndDestroy(2,filter);

			break;

			}

		case ESingleLookup:

			{

			//Read the decision values from the config file

			ReadDecisionFieldsL(ETrue);

			TInt expectedRecords;

			if(EFalse == GetIntFromConfig(ConfigSection(),KExpectedRecords,expectedRecords))

				{

				ERR_PRINTF1(_L("Expected result is missing!"));

				SetTestStepResult(EFail);

				break;

				}

			TPtrC strExpectedResult;

			TInt expectedResult=KErrNone;

			if(GetStringFromConfig(ConfigSection(),KExpectedResult,strExpectedResult))

				{

				expectedResult = ConvertNumber(strExpectedResult);

				}

			//Create filter

			filter = CreateFilterL(iSetFlag,iClientSid,iEvaluatorId,iServiceId,iServerSid,iFingerprint,iClientEntity,iMajorPolicyVersion,iRecordId,iDescription,iResult,iEvaluatorInfo,iComparison);

			CleanupStack::PushL(filter);

			//Connect to the database

			upsDb = CDecisionDbW::NewLC(iDbLocation,iFs);

			//Retrieve single record

			TRAPD(err,record = GetDecisionLC(*upsDb, *filter);if(record)CleanupStack::Pop(record););

			if((err==KErrNone)&&(record))

				{

				CleanupStack::PushL(record);

				}

			if(err!=expectedResult)

				{

				SetTestStepResult(EFail);

				}

			if(record)

				{

				OpenDecisionFileL(EFileWrite);

				WriteDecisionL(*record);

				CloseDecisionFile();

				CleanupStack::PopAndDestroy();

				}

			else

				{

				if(expectedRecords)

					{

					ERR_PRINTF1(_L("Failed to retrieve a single record"));

					SetTestStepResult(EFail);

					}

				}

			CleanupStack::PopAndDestroy(upsDb);

			CleanupStack::PopAndDestroy(filter);

			break;			

			}

		case EMultipleLookup:

			{

			//Read the decision values from the config file

			ReadDecisionFieldsL(ETrue);

			//Create filter

			filter = CreateFilterL(iSetFlag,iClientSid,iEvaluatorId,iServiceId,iServerSid,iFingerprint,iClientEntity,iMajorPolicyVersion,iRecordId,iDescription,iResult,iEvaluatorInfo,iComparison);

			CleanupStack::PushL(filter);

			//Connect to the database

			upsDb = CDecisionDbW::NewL(iDbLocation,iFs);

			CleanupStack::PushL(upsDb);

			TInt recNum;

			recNum = recordList.Count();

			if(recNum)

				OpenDecisionFileL(EFileWrite);

				for(TInt i=0; i<recNum; ++i)

					{

					WriteDecisionL(*recordList[i]);

					}

				}

			TInt expectedRecords;

			if(EFalse == GetIntFromConfig(ConfigSection(),KExpectedRecords,expectedRecords))

				{

				expectedRecords=-1;

				}

			if(!iCancel && (((expectedRecords>=0) && (recNum != expectedRecords))||((expectedRecords<0) && (recNum<=0))))

				{

				SetTestStepResult(EFail);

				}

			CleanupStack::PopAndDestroy(2,filter);

			break;	

			}

		case EVerifyRecord:

			{

			//Read the decision values from the config file

			ReadDecisionFieldsL(ETrue);

			TBool verified = ETrue;

			OpenDecisionFileL(EFileRead);

			while((record = ReadDecisionL()) != NULL)

				{

				CleanupStack::PushL(record);

				if(iSetFlag & KSetClientSid)

					{

					if(record->iClientSid != TSecureId(iClientSid))

						{

						verified = EFalse;

						break;

						}

					}

				if(iSetFlag & KSetEvaluatorId)

					{

					if(record->iEvaluatorId != TUid::Uid(iEvaluatorId))

						{

						verified = EFalse;

						break;

						}

					}

				if(iSetFlag & KSetServiceId)

					{

					if(record->iServiceId != TUid::Uid(iServiceId))

						{

						verified = EFalse;

						break;

						}

					}

				if(iSetFlag & KSetServerSid)

					{

					if(record->iServerSid != TSecureId(iServerSid))