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

// Example CTestStep derived implementation

// 

//

/**

 @file SimPsyStep.cpp

 @internalTechnology

*/

#include "simpsystep.h"

#include "te_lbssimulationpsysuitedefs.h"

#include "lbssystemcontroller.h"

#include <lbs.h>

#include <centralrepository.h>

#include <lbs/simulationpsyinternalcrkeys.h>

#include "CPosFileReader.h"

#include "EPos_TDesTokeniser.h"

#include "CSimPsyMultiRequester.h"

#include "CSimPsyRequester.h"

//#include "CSimPsyMultiNmeaRequester.h"

// A few useful macros

#define MAX(x,y)      ((x)<(y))?(y):(x)

#define MIN(x,y)      ((x)<(y))?(x):(y)

GLREF_C TPositionModuleStatus ModuleStatus();

GLREF_C TPositionModuleStatus PrevModuleStatus();

// CONSTANTS

//_LIT(KSimPsyName,"Simulation PSY");

_LIT(KSimPsyName,"Simulation");

_LIT(KSimFile, "c:\\system\\data\\simulationdata.sps");

_LIT(KDeterministicFile, "c:\\system\\data\\simulationData_deterministic.sps");

_LIT(KRandomFile, "c:\\system\\data\\simulationData_random.sps");

_LIT(KSimMoveAndBundFile, "c:\\system\\data\\simulationData_simmove_bund.sps");

_LIT(KSimSamePlace, "c:\\system\\data\\simulationdata_same_place.sps");

_LIT(KSimPositiveLongitudeWrapAroundFile, "c:\\system\\data\\simulationData_longwrap1.sps");

_LIT(KSimNegativeLongitudeWrapAroundFile, "c:\\system\\data\\simulationData_longwrap2.sps");

_LIT(KSimWrongHorAcc_File, "c:\\system\\data\\simulationData_wrongHorAcc.sps");

_LIT(KSimWrongVerAcc_File, "c:\\system\\data\\simulationData_wrongVerAcc.sps");

_LIT(KSimWrongLongitude_File, "c:\\system\\data\\simulationData_wrongLongitude.sps");

_LIT(KSimWrongLongitudeMax_File, "c:\\system\\data\\simulationData_wrongLongitudeMax.sps");

_LIT(KSimWrongLatitude_File, "c:\\system\\data\\simulationData_wrongLatitude.sps");

_LIT(KSimWrongLatitudeMax_File, "c:\\system\\data\\simulationData_wrongLatitudeMax.sps");

_LIT(KSimWrongSpeed_File, "c:\\system\\data\\simulationData_wrongSpeed.sps");

_LIT(KSimWrongCourse_File, "c:\\system\\data\\simulationData_wrongCourse.sps");

_LIT(KSimWrongTTF_min_File, "c:\\system\\data\\simulationData_wrongTTF_min.sps");

_LIT(KSimWrongTTF_max_File, "c:\\system\\data\\simulationData_wrongTTF_max.sps");

_LIT(KSimWrongPowerupTimeFile, "c:\\system\\data\\simulationData_wrong_poweruptime.sps");

_LIT(KSimWrongDeterministicFile, "c:\\system\\data\\simulationData_wrong_deterministic.sps");

_LIT(KSimWrongNumOfItemsFile, "c:\\system\\data\\simulationData_wrongNumberOfItems.sps");

_LIT(KSimWrongWordFile, "c:\\system\\data\\simulationData_wrongWordDoc.sps");

const TReal KEarthRadius = 6371010;

const TReal KPI = 3.1415926535897932384626433832795;

const TInt32 KSimModuleId = 270498433;

CSimPsyStep::~CSimPsyStep()

/**

 * Destructor

 */

	{

    iFileReader->CloseResources();

    delete iFileReader;

    iFileReader = NULL;

    delete iSimDataArray; 

    iSimDataArray = NULL;

#ifdef __CTC__ 

    #pragma CTC APPEND

#endif

	}

CSimPsyStep::CSimPsyStep()

/**

 * Constructor

 */

	{

	// **MUST** call SetTestStepName in the constructor as the controlling

	// framework uses the test step name immediately following construction to set

	// up the step's unique logging ID.

	SetTestStepName(KSimPsyStep);

	}

TVerdict CSimPsyStep::doTestStepPreambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	// uncomment the following 3 lines if you have common pre setting to all the test steps in there

	CTe_LbsSimulationPSYSuiteStepBase::doTestStepPreambleL();

	// if (TestStepResult()!=EPass)

	//    return   TestStepResult();

	// process some pre setting to this test step then set SetTestStepResult to EFail or Epass.

	SetTestStepResult(EPass);

	TTime time;

	time.UniversalTime();            

	iSeed = time.Int64();            

	iSimDataArray = new (ELeave) CDesC8ArrayFlat(10);                                                 

	iFileReader = CPosFileReader::NewL(); 

	SetSimDataFileL(KSimFile);

	ReadSimDataFromFileL(KSimFile);

	return TestStepResult();

	}

TVerdict CSimPsyStep::doTestStepL()

/**

 * @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.

 */

	{

	  if (TestStepResult()==EPass)

		{

		TInt test;

		if(!GetIntFromConfig(ConfigSection(),KTe_LbsSimulationPSYSuiteInt,test)

			)

			{

			// Leave if there's any error.

			User::Leave(KErrNotFound);

			}

		SetTestStepResult(EPass);

		StartL(test);

		}

	  return TestStepResult();

	}

TVerdict CSimPsyStep::doTestStepPostambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	// process something post setting to the test step

	// uncomment the following line if you have common post setting to all the test steps in there

	// CTe_LbsSimulationPSYSuiteStepBase::doTestStepPostambleL();

	// uncomment the following line if you have post process or remove the following line if no post process

	// SetTestStepResult(EPass);		// or EFail

	return TestStepResult();

	}

// ---------------------------------------------------------

// CSimPsyStep::StartL

// (other items were commented in a header).

// ---------------------------------------------------------

//    

void CSimPsyStep::StartL(TInt aIndex)

    {

    switch (aIndex)

        {

        case 0:

        	_LIT(KSingleTestName, "**** Single request test ****");

        	INFO_PRINTF1(KSingleTestName);

        	TestSingleRequestL(); 

        	break;                    

        case 1:

        	_LIT(KSingleCancelTest, "**** Single cancel test ****");

        	INFO_PRINTF1(KSingleCancelTest);

        	TestSingleCancelTestL(); 

        	break;

        case 2: 

        	_LIT(KMultCancelTest, "**** Multiple cancel test %d ****"); 

        	INFO_PRINTF1(KMultCancelTest);

        	TestMultipleCancelTestL(EFalse, EFalse, ETrue); 

        	break;

        case 3: TestMultipleCancelTestL(ETrue, EFalse, ETrue); break;

        case 4: TestMultipleCancelTestL(ETrue, ETrue, ETrue); break;        

        case 5: 

        	_LIT(KSimulatedMovements, "**** Simulated movements ****");

        	INFO_PRINTF1(KSimulatedMovements);

        	TestSimulatedMovementsL(5); 

        	break;        

        case 6: 

        	_LIT(KDeterministicFailure, "**** Deterministic failure ****"); 

        	INFO_PRINTF1(KDeterministicFailure);

        	TestDeterministicFailureL(); 

        	break;        

        case 7:

        	_LIT(KRandomFailure, "**** Random failure ****"); 

        	INFO_PRINTF1(KRandomFailure);

        	TestRandomFailureL(); 

        	break;        

        case 8: 

        	_LIT(KMultipleRequestsMemoryTestName, "**** Multiple requests memory leak test ****");

        	INFO_PRINTF1(KMultipleRequestsMemoryTestName);

        	//TestMultipleRequestsL(20); 

        	HeapTestL(aIndex);

        	break;        

        case 9:

        	_LIT(KMultipleRequestsAndCancelMemoryTestName, "**** Multiple requests and cancel memory leak test ****");

        	INFO_PRINTF1(KMultipleRequestsAndCancelMemoryTestName);

        	//TestMultipleRequestsAndCancelL(2/*20*/, EFalse, ETrue, EFalse); 

        	HeapTestL(aIndex);

        	break;        

        case 10: 

        	_LIT(KLongitudeWraparoundTestName, "**** Longitude wraparound test ****");    

        	INFO_PRINTF1(KLongitudeWraparoundTestName);

        	TestLongitudeWrapAroundL(); 

        	break;        

        case 11:

        	_LIT(KBadSimFile, "**** Bad Simulation Data file ****");

        	INFO_PRINTF1(KBadSimFile);

        	TestBadSimulationDataFileL(); 

        	break;        

        case 12: 

        	_LIT(KReqTimeAfterCancel, "**** Request Time after Cancel ****");

        	INFO_PRINTF1(KReqTimeAfterCancel);

        	TestRequestTimeAfterCancelL(); 

        	break;  

        case 13: 

        	_LIT(KReqCancelReq, "**** Request Cancel Request with Time ****");

        	INFO_PRINTF1(KReqCancelReq);

        	TestRequestCancelRequestL(); 

        	break;

        case 14: 

        	_LIT(KStatusEvent, "**** Status Event test ****");

        	INFO_PRINTF1(KStatusEvent);

        	TestStatusEventL(); 

        	break;

        case 15: 

        	_LIT(KModuleInfo, "**** Module Info test ****");

        	INFO_PRINTF1(KModuleInfo);

        	TestModuleInfoL(); 

        	break;

        case 16: 

        	_LIT(KStillStanding, "**** Standing still test ****");

        	INFO_PRINTF1(KStillStanding);

        	TestStandingStillL(); 

        	break;

        default: break;

        }

    }

void CSimPsyStep::DoTestL(TInt aIndex)

    {

    switch (aIndex)

        {

        case 0: TestSingleRequestL(); break;                    

        case 1: TestSingleCancelTestL(); break;

        case 2: TestMultipleCancelTestL(EFalse, EFalse, ETrue); break;

        case 3: TestMultipleCancelTestL(ETrue, EFalse, ETrue); break;

        case 4: TestMultipleCancelTestL(ETrue, ETrue, ETrue); break;        

        case 5: TestSimulatedMovementsL(5); break;        

        case 6: TestDeterministicFailureL(); break;        

        case 7: TestRandomFailureL(); break;        

        case 8: TestMultipleRequestsL(20); break;        

        case 9: TestMultipleRequestsAndCancelL(2/*20*/, EFalse, ETrue, EFalse); break;        

        case 10: TestLongitudeWrapAroundL(); break;        

        case 11: TestBadSimulationDataFileL(); break;        

        case 12: TestRequestTimeAfterCancelL(); break;  

        case 13: TestRequestCancelRequestL(); break;

        case 14: TestStatusEventL(); break;

        case 15: TestModuleInfoL(); break;

        case 16: TestStandingStillL(); break;

        default: break;

        }

    }

// ---------------------------------------------------------

// CSimPsyStep::TestSingleRequestL

// (other items were commented in a header).

// ---------------------------------------------------------

//       

void CSimPsyStep::TestSingleRequestL()

    {

    CSimPsyMultiRequester* requester = CSimPsyMultiRequester::NewLC();

    TInt status;

    TPositionInfo position;

    TPosition pos, pos2;    

    TTimeIntervalMicroSeconds requestTime;

    requester->MakeRequests();

    requester->GetResult(status, position, requestTime);           

    CheckRequestResultL(status, position);            

	CheckRequestTimeL(KSimFile, ETrue, position, requestTime);            

	position.GetPosition(pos);

	requester->MakeRequests();

    requester->GetResult(status, position, requestTime);     

	CheckRequestTimeL(KSimFile, EFalse, position, requestTime);

	position.GetPosition(pos2);

	// Check if first altitude is != 0.0 

	if (pos.Altitude() != 0.0)

        {

        _LIT(KLong, "Expected altitude == 0.0, but got: %d.");

		TBuf<60> buf;

        buf.Format(KLong, pos.Altitude());

        LogErrorAndFail(buf);

        }

	// Check if first altitude is same as the second

	if (pos.Altitude() == pos2.Altitude())

        {

        _LIT(KLong, "Expected altitude != previous altitude. %d.");

		TBuf<50> buf;

        buf.Format(KLong, pos2.Altitude());

        LogErrorAndFail(buf);

        }

    CleanupStack::PopAndDestroy(); // requester  

	_LIT(KSingleTestName, "Ended: **** Single request test ****");

	INFO_PRINTF1(KSingleTestName);

    }

// ---------------------------------------------------------

// CSimPsyStep::TestSingleCancelTestL

// (other items were commented in a header).

// ---------------------------------------------------------

//       

void CSimPsyStep::TestSingleCancelTestL()

    {            

    SetSimDataFileL(KSimMoveAndBundFile);

    CSimPsyMultiRequester* requester = CSimPsyMultiRequester::NewLC();

    requester->SetRequesterWillCancelL();

    TPositionInfo position;

    TInt status;

    TTimeIntervalMicroSeconds requestTime;

    requester->StopRequests();

    requester->MakeRequests();

    requester->GetResult(status, position, requestTime);

    if (status != KErrCancel)

        {

        _LIT(KReqWasNotCancelled, "The request was not cancelled");

        LogErrorAndFail(KReqWasNotCancelled);

        }

	TPosition pos;

	position.GetPosition(pos);

    if (pos.Time().Int64() != 0.0)

        {

        _LIT(KHasPosition, "The cancelled request returned a position");

        LogErrorAndFail(KHasPosition);        

        }

    CleanupStack::PopAndDestroy(); // requester    

	_LIT(KSingleCancelTest, "Ended: **** Single cancel test ****");

	INFO_PRINTF1(KSingleCancelTest);

    }

// ---------------------------------------------------------

// CSimPsyStep::TestSimpleCancelTestL

// (other items were commented in a header).

// ---------------------------------------------------------

//       

void CSimPsyStep::TestMultipleCancelTestL(

	TBool aFirstWillCancel,

	TBool aSecondWillCancel,

	TBool aThirdWillCancel)

    {

    SetSimDataFileL(KSimMoveAndBundFile);

    CSimPsyMultiRequester* requester = CSimPsyMultiRequester::NewLC(3);

    if (aFirstWillCancel)

        {

        requester->SetRequesterWillCancelL(0);

        }

    if (aSecondWillCancel)

        {

        requester->SetRequesterWillCancelL(1);

        }

    if (aThirdWillCancel)

        {

        requester->SetRequesterWillCancelL(2);

        }

    TPositionInfo position;

    TInt status;

    TTimeIntervalMicroSeconds requestTime;

    requester->MakeRequests();

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

        {

        requester->GetResult(status, position, requestTime, i);

		TPosition pos;

		position.GetPosition(pos);

        TBool shouldHaveCancelled = 

            (i == 0) ? aFirstWillCancel

            : (i == 1) ? aSecondWillCancel

            : aThirdWillCancel;

        if (shouldHaveCancelled)

            {

            if (status != KErrCancel)

                {

                _LIT(KReqWasNotCancelled, "The request was not cancelled");

                LogErrorAndFail(KReqWasNotCancelled);

                }

            if (pos.Time().Int64() != 0.0)

                {

                _LIT(KHasPosition, "The cancelled request returned a position");

                LogErrorAndFail(KHasPosition);        

                }

            }

        else

            {

            if (status != KErrNone)

                {

                _LIT(KReqFailed, "The request failed");

                LogErrorAndFail(KReqFailed);

                }

            if (pos.Time().Int64() == 0.0)

                {

                _LIT(KHasNoPosition, "The request did not return a position");

                LogErrorAndFail(KHasNoPosition);        

                }

            }

        }

    CleanupStack::PopAndDestroy(); // requester       

	_LIT(KMultCancelTest, "Ended: **** Multiple cancel test ****"); 

	INFO_PRINTF1(KMultCancelTest);

    }

// ---------------------------------------------------------

// CSimPsyStep::TestDeterministicFailureL

// (other items were commented in a header).

// ---------------------------------------------------------

//       

void CSimPsyStep::TestDeterministicFailureL()

    {

    _LIT8(KDeterministic, "Deterministic*");

    const TUint8 KPosDataSeparator = '=';

    const TUint8 KPosDefaultDataEndMarker = ';';

    SetSimDataFileL(KDeterministicFile);

    ReadSimDataFromFileL(KDeterministicFile);

    CSimPsyMultiRequester* requester = CSimPsyMultiRequester::NewLC();    

    TInt status;

    TPositionInfo position;    

    TTimeIntervalMicroSeconds requestTime;        

    TInt failFrequency = 0;

    for (TInt i = 0; i < iSimDataArray->Count(); i++)

        {

        if (iSimDataArray->MdcaPoint(i).MatchF(KDeterministic) 

                != KErrNotFound)

            {

            TDesTokeniser tokeniser(iSimDataArray->MdcaPoint(i));

            tokeniser.NextToken(KPosDataSeparator);

            TPtrC8 value = tokeniser.NextToken(KPosDefaultDataEndMarker);                        

            TLex8	lexer(value);            

            lexer.Val(failFrequency);           

            break;

            }                

        }

    TBuf<20> buf;

    TInt request;

    TInt numberOfRequests = 10;

    TBool requestShouldFail = EFalse;

    for (request = 1; request <= numberOfRequests; request++)

        {

        if (failFrequency == 0)

            {

            requestShouldFail = EFalse;

            }

        else if (request % failFrequency == 0)

            {

            requestShouldFail = ETrue;

            }

        requester->MakeRequests();

        requester->GetResult(status, position, requestTime);

		if (request > 1)

			{

			CheckRequestTimeL(KDeterministicFile, EFalse, position, requestTime);

			}

        if (requestShouldFail)            

            {           

            requestShouldFail = EFalse;

			TPosition pos;

			position.GetPosition(pos);

			if (status != KPositionQualityLoss)

                {

                TBuf<40> output;

                _LIT(KStatusError, "KPositionQualityLoss was expected, but got %d");

                output.Format(KStatusError, status);

                LogErrorAndFail(output);

                }

            TBuf<30> buf;

            _LIT(KOut, "Failing request no : %d.");

            buf.Format(KOut, numberOfRequests);

            }

        else

            {

            CheckThatPositionExistsL(position);        

            }

        }

    CleanupStack::PopAndDestroy();  //requester

    TInt noOfClients = 4;

    requester = NULL;

    requester = CSimPsyMultiRequester::NewLC(noOfClients);