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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Symbian Foundation License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// @file ctlbsstepverifyloginfo.cpp

// This is the class implementation for the log verification test step

// 

//

#include "ctlbsstepverifyloginfo.h"

_LIT(KLogType, "log_type");

/**

Public, non-leaving, static constructor

*/

CT_LbsStep_VerifyLogInfo* CT_LbsStep_VerifyLogInfo::New(CT_LbsServer& aParent)

	{

	CT_LbsStep_VerifyLogInfo* self = NULL;

	// Note the lack of ELeave.

	// This means that having insufficient memory will return NULL;

	TRAPD(err, self = NewL(aParent));

	if(KErrNone != err)

		{

		self = NULL;

		}

	return self;

	}

/**

 * Static Constructor that may leave

 */

CT_LbsStep_VerifyLogInfo* CT_LbsStep_VerifyLogInfo::NewL(CT_LbsServer& aParent)

	{

	CT_LbsStep_VerifyLogInfo* verifyLog = new(ELeave) CT_LbsStep_VerifyLogInfo(aParent);

	CleanupStack::PushL(verifyLog);

	verifyLog->ConstructL();

	CleanupStack::Pop(verifyLog);

	return verifyLog;

	}

/**

2nd phase Constructor that may leave

*/

void CT_LbsStep_VerifyLogInfo::ConstructL()

	{

	// Create everything for the right hand side of all compares

	_LIT(KTheDest,"07712345678");

	TPtrC theDest(KTheDest);

	iX3PLogIntiailisedFromValues = CLbsTransmitLocationLogEvent::NewL(TUid::Uid(0), NULL, theDest);

	iSelfLocateLogIntiailisedFromValues = CLbsSelfLocateLogEvent::NewL(TUid::Uid(0), NULL);

	iExternalLocateLogIntiailisedFromValues = CLbsExternalLocateLogEvent::NewL(TUid::Uid(0), NULL, NULL);

	iNetworkLocateLogIntiailisedFromValues = CLbsNetworkLocateLogEvent::NewL(TUid::Uid(0), NULL);

	iAssistanceDataLogIntiailisedFromValuesFirst = CLbsAssistanceDataLogEvent::NewL(0, 0);	

	//Setup other reference position

	iRefPosTwo = new TPositionInfo();

	TPosition refpos;

	refpos.SetCoordinate(REFPOS_LAT, REFPOS_LONG, REFPOS_ALT);

	refpos.SetAccuracy(REFPOS_HORZ_ACCURACY, REFPOS_VERT_ACCURACY);

	refpos.SetCurrentTime();

	iRefPosTwo->SetPosition(refpos);

	// read logs using CLogViewEvent

	TInt ErrorCode = itheFs.Connect();

	if(ErrorCode)

		{

		INFO_PRINTF1(_L("\t Error: Open FileServer failed."));

		SetTestStepResult(EFail);

		}

    iclient = CLogClient::NewL(itheFs, CActive::EPriorityStandard);

	iview = CLogViewEvent::NewL(*iclient, CActive::EPriorityStandard);

	iActiveWaiter = CT_LbsAsyncWaiter::NewL();			// NEW iActiveWaiter

	}

/**

 * Destructor

 */

CT_LbsStep_VerifyLogInfo::~CT_LbsStep_VerifyLogInfo()

	{

	iview->Cancel();

	iclient->Cancel();

	delete iview;

	delete iclient;

	itheFs.Close();

	delete iActiveWaiter;

	// Delete everything for the right hand side of all compares

	delete iRefPosTwo;

	delete iSelfLocateLogIntiailisedFromValues;

	delete iExternalLocateLogIntiailisedFromValues;

	delete iNetworkLocateLogIntiailisedFromValues;

	delete iAssistanceDataLogIntiailisedFromValuesFirst;

	delete iX3PLogIntiailisedFromValues;

	}

/**

 * Constructor

 */

CT_LbsStep_VerifyLogInfo::CT_LbsStep_VerifyLogInfo(CT_LbsServer& aParent) : CT_LbsStep(aParent)

	{

	SetTestStepName(KLbsStep_VerifyLogInfo);

	}

TVerdict CT_LbsStep_VerifyLogInfo::doTestStepPreambleL()

	{

	return TestStepResult();

	}

TVerdict CT_LbsStep_VerifyLogInfo::doTestStepPostambleL()

	{

	return TestStepResult();

	}

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 * Our implementation only gets called if the base class doTestStepPreambleL() did

 * not leave. That being the case, the current test result value will be EPass.

 */

TVerdict CT_LbsStep_VerifyLogInfo::doTestStepL()

	{

	// Helper test step used to Verify the Position Information Array.

	INFO_PRINTF1(_L(">>CT_LbsStep_VerifyLogInfo::doTestStepL()"));

	if (TestStepResult() == EPass)

		{

		// Left and right parameters of compare functions.

		if (GetIntFromConfig(ConfigSection(), KLogType, iLogType))

			{

			if(iParent.iSharedData->iTestModuleInUse) 

				{

				iWhatAccuracyToUse = T_LbsUtils::EExactAccuracy;

				}

			else

				{

				iWhatAccuracyToUse = T_LbsUtils::ERoughAccuracy;

				}

			InitialiseRHS();

			switch(iLogType)

				{

				case EAutonomousSelfLocateRequest: // Enum 0

	        		{

	        		AutonomousSelfLocateLogTest();

	        		}

				break;

				case EMOLRSelfLocateRequest: // Enum 1

		        	{

					MOLRSelfLocateRequest();

		        	}

		        break;

				case EMOLRCellBasedLocationRequest: // Enum 2

					{

					MOLRCellBasedLocationRequest();

					}

				break;

				case EMOLRTransmitTo3rdPartyLocationRequest: // Enum 3

				    {

					MOLRTransmitTo3rdPartyLocationRequest();

				    }

		       	break;

				case EMTLR: // Enum 4

		       		{

					MTLR();

		       		}

		       	break;

				case EMOLRTrackingLocationRequest: // Enum 5

			       	{

		       		MOLRTrackingLocationRequest();

		       		}

		       	break;

				case EAutonomousTrackingLocationRequest: // Enum 6

		       		{

		       		AutonomousTrackingLocationRequest();

		       		}

		       	break;

				default:

					{

					INFO_PRINTF1(_L("<FONT><B>Failed to match a test case Id.</B></FONT>"));

					SetTestStepResult(EFail);				

					}

				break;

				}// End of switch

			ClearLog();

			}// End of GetIntFromConfig()...

		} // End of "If TestStepResult..."

	INFO_PRINTF1(_L("<<CT_LbsStep_VerifyLogInfo::doTestStepL()"));

	return TestStepResult();

	}

TVerdict CT_LbsStep_VerifyLogInfo::ReadFromLogL(TInt aUidForTheLogType)

	{		

	/**

	 * Filter the type of log we are looking for based on UID 

	 */

	CLogFilter* filter = CLogFilter::NewL();			// NEW FILTER

	CleanupStack::PushL(filter);

	filter->SetEventType(TUid::Uid(aUidForTheLogType));

	/*

	 * Obtain the last added event from LBS logger 		

	 */

	TBool res = iview->SetFilterL(*filter, iActiveWaiter->iStatus);

	if (res == EFail)

		{

		INFO_PRINTF1(_L("\t Error: Set filter failed."));

		return EFail;

		}

	iActiveWaiter->StartAndWait();

	if (iActiveWaiter->iStatus != KErrNone)

		{

		INFO_PRINTF1(_L("\t Error: Create Log iview failed."));

		return EFail;

		}

	/* 

	 * Count how many of these events there are and 

	 * store each event in the relevant array 

	 */	 

	TInt count = iview->CountL();

	TLinearOrder<CLbsSelfLocateLogEvent> selfLocLogOrder(SelfLocateLogEventTimestampCompare);

	for(int i=0 ; i<count ; i++)

		{

		// Start at first event to have occured...

		if(i==0 && count > 0)

			{

			// Get first event in order of occurance

			if(!iview->LastL(iActiveWaiter->iStatus))

				{

				INFO_PRINTF2(_L("\t Error: Read last log failed with error %d."), iActiveWaiter->iStatus.Int());

				return EFail;

				}

			}

		if(i>0 && i<count)

			{

			// Cancel outstanding request...

			iActiveWaiter->Cancel();

			iActiveWaiter->StartAndWait();

			if (iActiveWaiter->iStatus != KErrNone)

				{

				INFO_PRINTF1(_L("\t Error: Failed to cancel outstanding request."));

				return EFail;

				}

			// Move onto the next event in order of occurance and store it in succession

			if(!iview->PreviousL(iActiveWaiter->iStatus))

				{

				INFO_PRINTF2(_L("\t Error: Read previous log failed with error %d."), iActiveWaiter->iStatus.Int());

				return EFail;	

				}

			}

		CLogEvent* logEvent = CLogEvent::NewL();		// NEW LOGEVENT

		CleanupStack::PushL(logEvent);

		logEvent->CopyL(iview->Event());

		// Pass ownership to the relevant array

		switch(aUidForTheLogType) 

		{

		case KLogLbsSelfLocateEventType:

			{

			RPointerArray<CLbsSelfLocateLogEvent>& logInfoArr = iParent.iSharedData->iSelfLocateLogInfoArr;	

			CLbsSelfLocateLogEvent* selfLocateEv = static_cast<CLbsSelfLocateLogEvent*>(CLbsLogEvent::NewL(*logEvent));

			CleanupStack::PushL(selfLocateEv);

			// SelfLoc Log events seem to be returned out of order, so wee need to sort them

			logInfoArr.InsertInOrder(selfLocateEv, selfLocLogOrder);

			CleanupStack::Pop(selfLocateEv);

			}

			break;

		case KLogLbsNetworkLocateEventType:

			{

			RPointerArray<CLbsNetworkLocateLogEvent>& logInfoArr = iParent.iSharedData->iNetworkLocateLogInfoArr;	

			CLbsNetworkLocateLogEvent* networkLocateEv = static_cast<CLbsNetworkLocateLogEvent*>(CLbsLogEvent::NewL(*logEvent));

			CleanupStack::PushL(networkLocateEv);

			logInfoArr.AppendL(networkLocateEv); // Store it in the array

			CleanupStack::Pop(networkLocateEv);			}

			break;

		case KLogLbsExternalLocateEventType:

			{

			RPointerArray<CLbsExternalLocateLogEvent>& logInfoArr = iParent.iSharedData->iExternalLocateLogInfoArr;			

			CLbsExternalLocateLogEvent* externalLocateEv = static_cast<CLbsExternalLocateLogEvent*>(CLbsLogEvent::NewL(*logEvent));

			CleanupStack::PushL(externalLocateEv);

			logInfoArr.AppendL(externalLocateEv); // Store it in the array

			CleanupStack::Pop(externalLocateEv);

			}

		break;

		case KLogLbsTransmitLocationEventType:

			{

			RPointerArray<CLbsTransmitLocationLogEvent>& logInfoArr = iParent.iSharedData->iX3PLocateLogInfoArr;			

			CLbsTransmitLocationLogEvent* x3pLocateEv = static_cast<CLbsTransmitLocationLogEvent*>(CLbsLogEvent::NewL(*logEvent));

			CleanupStack::PushL(x3pLocateEv);

			logInfoArr.AppendL(x3pLocateEv); // Store it in the array

			CleanupStack::Pop(x3pLocateEv);

			}

		break;

		case KLogLbsAssistanceDataEventType:

			{

			RPointerArray<CLbsAssistanceDataLogEvent>& logInfoArr = iParent.iSharedData->iAssistanceDataLogInfoArr;	

			CLbsAssistanceDataLogEvent* assistanceLogEv = static_cast<CLbsAssistanceDataLogEvent*>(CLbsLogEvent::NewL(*logEvent));

			CleanupStack::PushL(assistanceLogEv);

			logInfoArr.AppendL(assistanceLogEv); // Store it in the array

			CleanupStack::Pop(assistanceLogEv);

			}

		break;	

		default:

			{

			INFO_PRINTF1(_L("\t Error: Couldnt match UID to a testable logtype."));

			i = count; // Force loop exit

			SetTestStepResult(EFail);

			}		

		}

		// Cleanup scoped variables

		CleanupStack::PopAndDestroy(logEvent);

		}// End of for loop

		// Cancel outstanding request...

		iActiveWaiter->Cancel();

		iActiveWaiter->StartAndWait();

		if (iActiveWaiter->iStatus != KErrNone)

			{

			INFO_PRINTF1(_L("\t Error: Failed to cancel any outstanding requests."));

			return EFail;

			}

	// Cleanup local variables

	CleanupStack::PopAndDestroy(filter);

	return EPass;	

	}

void CT_LbsStep_VerifyLogInfo::SelfLocateLogTest()

	{

	INFO_PRINTF1(_L("* * * * * * * * * * * * * * * * * * * * * *"));

	INFO_PRINTF1(_L("SelfLocateLogTest>>"));

	TVerdict res;

	TBool compareResult;

	//	Empty SharedData values between update options tests

	iParent.iSharedData->iSelfLocateLogInfoArr.Reset();

	// reads all self-locate log entries into iSelfLocateLogInfoArr:

	res = ReadFromLogL(KLogLbsSelfLocateEventType);

	if (res == EFail) // if readfromlog fails...

		{

		INFO_PRINTF1(_L("<FONT><b>SelfLocateRequest > ReadFromLog Failed</b></font>"));

		SetTestStepResult(EFail);

		}

	else

		{

		// Compare DB log event and expected log event

		INFO_PRINTF1(_L("SelfLocateRequest > About to compare..."));

		RPointerArray<CLbsSelfLocateLogEvent>& logInfoArr = iParent.iSharedData->iSelfLocateLogInfoArr;

		TInt sizeOfArray = logInfoArr.Count();

		if(	((sizeOfArray != 2) && (iLogType == EAutonomousTrackingLocationRequest)) ||

			((sizeOfArray != 3) && (iLogType == EMOLRTrackingLocationRequest))

			)

			{

			INFO_PRINTF2(_L("<FONT><b>Update Log test failed, there were %d Self Locate events</b></font>"),sizeOfArray);

			SetTestStepResult(EFail);

			}

		else

			{

			//	Change reference location to be expected value

			TPositionInfo* posInfoSecond = new TPositionInfo();

			SecondPositionFromArray(posInfoSecond);

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

				{

				// note that events are in reverse order, therefore the reference position is last rather than first of 2

				if(iLogType == EMOLRTrackingLocationRequest && i == 2)

					{

					iSelfLocateLogIntiailisedFromValues->SetPositionInfo(posInfoSecond);		

					}

				if(iLogType == EMOLRSelfLocateRequest && i == 1)

					{

					iSelfLocateLogIntiailisedFromValues->SetPositionInfo(posInfoSecond);

					}

				compareResult = iUtils.Compare_SelfLocateLog(	*(reinterpret_cast<CLbsSelfLocateLogEvent*>(logInfoArr[i])) , 

																*iSelfLocateLogIntiailisedFromValues

															);	

				if(!compareResult)

					{

					INFO_PRINTF2(_L("<FONT><b>SelfLocateRequest > compare returns false for element %d...</b></font>"),i);

					SetTestStepResult(EFail);

					}

				else

					{

					INFO_PRINTF1(_L("SelfLocateRequest > compare returns true..."));

					}

				}

			delete posInfoSecond;

			}

		}

	INFO_PRINTF1(_L("SelfLocateLogTest<<"));

	INFO_PRINTF1(_L("* * * * * * * * * * * * * * * * * * * * * *"));

	}

void CT_LbsStep_VerifyLogInfo::NetworkLocateLogTest()

	{

	INFO_PRINTF1(_L("* * * * * * * * * * * * * * * * * * * * * *"));

	INFO_PRINTF1(_L("NetworkLocateLogTest>>"));

	TVerdict res;

	TBool compareResult;

	res = ReadFromLogL(KLogLbsNetworkLocateEventType);

	if (res == EFail) // if readfromlog fails...

		{

		INFO_PRINTF1(_L("<FONT><b>NetworkLocateRequest > Readfrom log failed</b></font>"));

		SetTestStepResult(EFail);

		}

	else

		{

		// Compare DB log event and expected log event

		INFO_PRINTF1(_L("NetworkSelfLocateRequest > About to compare..."));

		RPointerArray<CLbsNetworkLocateLogEvent>& logInfoArr = iParent.iSharedData->iNetworkLocateLogInfoArr;

		TInt sizeOfArray = logInfoArr.Count();

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

			{

			compareResult = iUtils.Compare_NetworkLocateLog(	*(reinterpret_cast<CLbsNetworkLocateLogEvent*>(logInfoArr[i])) , 

																*iNetworkLocateLogIntiailisedFromValues

														);	

			if(!compareResult)

				{

				INFO_PRINTF2(_L("<FONT><b>NetworkLocateRequest > compare returns false for element %d...</b></font>"),i);

				SetTestStepResult(EFail);

				}

			else

				{

				INFO_PRINTF1(_L("NetworkLocateRequest > compare returns true..."));

				}	

			}

		}

	INFO_PRINTF1(_L("NetworkLocateLogTest<<"));

	INFO_PRINTF1(_L("* * * * * * * * * * * * * * * * * * * * * *"));

	}

void CT_LbsStep_VerifyLogInfo::ExternalLocateLogTest()

	{

	INFO_PRINTF1(_L("* * * * * * * * * * * * * * * * * * * * * *"));

	INFO_PRINTF1(_L("ExternalLocateLogTest>>"));

	TVerdict res;

	TBool compareResult;

	res = ReadFromLogL(KLogLbsExternalLocateEventType);

	if (res == EFail) // if readfromlog fails...

		{

		INFO_PRINTF1(_L("<FONT><b>ExternalLocateRequest > ReadFromLog Failed</b></font>"));

		SetTestStepResult(EFail);

		}

	else

		{

		// Compare DB log event and expected log event

		INFO_PRINTF1(_L("NetworkSelfLocateRequest > About to compare..."));

		RPointerArray<CLbsExternalLocateLogEvent>& logInfoArr = iParent.iSharedData->iExternalLocateLogInfoArr;

		TInt sizeOfArray = logInfoArr.Count();

		TPositionInfo* posInfoSecond = new TPositionInfo();

		TPositionInfo* commonPosinfo = CommonPositionInfo();

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