// 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 SimPsyNmeaPositionerStep.cpp

 @internalTechnology

*/

#include "simpsynmeapositionerstep.h"

#include "te_lbssimulationpsysuitedefs.h"

#include "CSimPsyMultiNmeaPosRequester.h"

#include <lbs.h>

#include <lbssatellite.h>

// A few useful macros

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

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

// CONSTANTS

_LIT(KNmeaFile, "c:\\system\\data\\nmea.nme");

_LIT(KNmeaShortFile, "c:\\system\\data\\nmea_short.nme");

_LIT(KWrongFileType, "c:\\system\\data\\simfile.wng");

_LIT(KNmeaSatelliteFile, "c:\\system\\data\\nmea_garmin3plus.nme");

_LIT(KNmeaMagellanFile, "c:\\system\\data\\nmea_Magellantracker.nme");

_LIT(KNmeaPdopMissingFile, "c:\\system\\data\\nmea_pdopmissing.nme");

_LIT(KNmeaPartialUpdateFile, "c:\\system\\data\\nmea_partial_updates.nme");

_LIT(KNmeaError1, "c:\\system\\data\\nmea_error1.nme");

_LIT(KNmeaError2, "c:\\system\\data\\nmea_error2.nme");

_LIT(KNmeaError3, "c:\\system\\data\\nmea_error3.nme");

_LIT(KNmeaSpecialCase, "c:\\system\\data\\nmea_special_case.nme");

const TInt32 KSimModuleId = 270498433;

CSimPsyNmeaPositionerStep::~CSimPsyNmeaPositionerStep()

/**

 * Destructor

 */

	{

    iFileReader->CloseResources();    

    delete iSimDataArray; 

    iSimDataArray = NULL;

    delete iFileReader;

    iFileReader = NULL;

#ifdef __CTC__ 

    #pragma CTC APPEND

#endif

	}

CSimPsyNmeaPositionerStep::CSimPsyNmeaPositionerStep()

/**

 * 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(KSimPsyNmeaPositionerStep);

	}

TVerdict CSimPsyNmeaPositionerStep::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();            

	iFileReader = CPosFileReader::NewL();  

	return TestStepResult();

	}

TVerdict CSimPsyNmeaPositionerStep::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 CSimPsyNmeaPositionerStep::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();

	}

// ================= MEMBER FUNCTIONS =======================

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

// CSimPsyNmeaPositionerStep::FixSettingsForSimPSY

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

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

// 

void CSimPsyNmeaPositionerStep::FixSettingsForSimPSY(const TDesC& aFileName) 

	{	

    // Third version of settings simulation psy file

	TFileName fileName = aFileName;

    CRepository* repository = CRepository::NewLC(KCRUidSimulationPSY);

    User::LeaveIfError(repository->Set(KCRKeySimPSYSimulationFile, fileName));

    CleanupStack::PopAndDestroy(repository);

	}

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

// CSimPsyNmeaPositionerStep::StartL

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

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

//    

void CSimPsyNmeaPositionerStep::StartL(TInt aIndex)

    {

    switch (aIndex)

        {                   

        case 0:

        	_LIT(KSingleNmeaRequestTest, "**** Single nmea request test ****");

        	INFO_PRINTF1(KSingleNmeaRequestTest);

        	FixSettingsForSimPSY(KNmeaFile); 

        	//TestSingleNmeaRequestL(); 

        	HeapTestL(aIndex);

        	break;                        

        case 1:

        	_LIT(KSingleNmeaCancelTest, "**** Single nmea cancel test ****");

        	INFO_PRINTF1(KSingleNmeaCancelTest);

        	FixSettingsForSimPSY(KNmeaFile); 

        	CancelSingleNmeaRequestL(); 

        	break;  

        case 2: 

        	_LIT(KMultCancelTest, "****  Multiple cancel test 1 ****");

        	INFO_PRINTF1(KMultCancelTest);

        	FixSettingsForSimPSY(KNmeaFile); 

        	TestMultipleNmeaCancelTestL(EFalse, EFalse, ETrue); 

        	break;  

        case 3: 

        	_LIT(KMultCancelTest2, "**** Multiple cancel test 2 ****");

        	INFO_PRINTF1(KMultCancelTest2);

        	FixSettingsForSimPSY(KNmeaFile); 

        	TestMultipleNmeaCancelTestL(ETrue, EFalse, ETrue); 

        	break;

        case 4: 

        	_LIT(KMultCancelTest3, "**** Multiple cancel test 3 ****");

            INFO_PRINTF1(KMultCancelTest3);

        	FixSettingsForSimPSY(KNmeaFile); 

        	TestMultipleNmeaCancelTestL(ETrue, ETrue, ETrue); 

        	break;                        

        case 5:

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

        	INFO_PRINTF1(KMultipleRequestsMemoryTestName);

        	FixSettingsForSimPSY(KNmeaFile); 

        	//TestMultipleRequestsL(10); 

        	HeapTestL(aIndex);

        	break;        

        case 6: 

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

            INFO_PRINTF1(KMultipleRequestsAndCancelMemoryTestName);

        	FixSettingsForSimPSY(KNmeaFile); 

        	TestMultipleRequestsAndCancelL(5, EFalse, ETrue, EFalse); 

        	break;        

        case 7:	

        	_LIT(KRequestNmeaData, "**** Request Nmea data ****");

        	INFO_PRINTF1(KRequestNmeaData);

        	FixSettingsForSimPSY(KNmeaFile); 

        	//TestRequestNmeaDataL(); 

        	HeapTestL(aIndex);

        	break;                        

        case 8: 

        	_LIT(KReadUntilEof, "**** Read until eof ****");

        	INFO_PRINTF1(KReadUntilEof);

        	//TestReadUntilEofL(); 

        	HeapTestL(aIndex);

        	break;                        

        case 9:

        	_LIT(KWrongPsyMode, "**** Unknown PSY mode ****"); 

        	INFO_PRINTF1(KWrongPsyMode);

        	TestWrongSimModeL(); 

        	break;  

        case 10: 

        	_LIT(KRequestCourseInfo, "**** Request course info ****");

        	INFO_PRINTF1(KRequestCourseInfo);

        	TestRequestCourseInfoL(); 

        	break;    

        case 11: 

        	_LIT(KRequestSatelliteInfo, "**** Request satellite info ****");

        	INFO_PRINTF1(KRequestSatelliteInfo);

        	TestRequestSatelliteInfoL(); 

        	break;

        case 12: 

        	_LIT(KRequestGenericInfo, "**** Request generic info ****");

        	INFO_PRINTF1(KRequestGenericInfo);

        	//TestRequestGenericInfoL(); 

        	HeapTestL(aIndex);

        	break;

        case 13: 

        	_LIT(KRequestBasicInfo, "**** Request basic info ****");

        	INFO_PRINTF1(KRequestBasicInfo);

        	TestRequestBasicInfoL(); 

        	break;

        case 14: 

        	_LIT(KRequestMagellan, "**** Request Magellan ****");

        	INFO_PRINTF1(KRequestMagellan);

        	TestRequestMagellanL(); 

        	break;

        case 15: 

        	_LIT(KRequestPartialGenericInfo, "**** Request partial generic info ****");

        	INFO_PRINTF1(KRequestPartialGenericInfo);

        	TestRequestPartialGenericInfoL(); 

        	break;

        case 16: 

        	_LIT(KRequestClearAndSetDefaultPositionData, "**** Test Clear Position Data ****");

        	INFO_PRINTF1(KRequestClearAndSetDefaultPositionData);

        	//TestClearAndSetDefaultPositionDataL(); 

        	HeapTestL(aIndex);

        	break;

        case 17: 

        	_LIT(KTestPartialUpdate, "**** Test Partial Update ****");

        	INFO_PRINTF1(KTestPartialUpdate);

        	TestPartialUpdateL(); 

        	break;

        case 18: 

        	_LIT(KTestErrorSituations, "**** Test wrong situations ****");

        	INFO_PRINTF1(KTestErrorSituations);

        	TestErrorSituationsL(); 

        	break;

        case 19: 

        	_LIT(KTestSpecialCase, "**** Test Special Case ****");

        	INFO_PRINTF1(KTestSpecialCase);

        	TestSpecialCasesL(); 

        	break;

        // Not a real test only a helper method for printing checksums

        default: 

        	break;

        }

    }

void CSimPsyNmeaPositionerStep::DoTestL(TInt aIndex)

    {

    switch (aIndex)

        {                   

        case 0: TestSingleNmeaRequestL(); break;                        

        case 1: CancelSingleNmeaRequestL(); break;  

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

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

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

        case 5: TestMultipleRequestsL(10); break;        

        case 6: TestMultipleRequestsAndCancelL(5, EFalse, ETrue, EFalse); break;        

        case 7: TestRequestNmeaDataL(); break;                        

        case 8: TestReadUntilEofL(); break;                        

        case 9: TestWrongSimModeL(); break;  

        case 10: TestRequestCourseInfoL(); break;    

        case 11: TestRequestSatelliteInfoL(); break;

        case 12: TestRequestGenericInfoL(); break;

        case 13: TestRequestBasicInfoL(); break;

        case 14: TestRequestMagellanL(); break;

        case 15: TestRequestPartialGenericInfoL(); break;

        case 16: TestClearAndSetDefaultPositionDataL(); break;

        case 17: TestPartialUpdateL(); break;

        case 18: TestErrorSituationsL(); break;

        case 19: TestSpecialCasesL(); break;

        // Not a real test only a helper method for printing checksums

        default: break;

        }

    }

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

// CSimPsyNmeaPositionerStep::TestSingleNmeaRequestL

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

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

//       

void CSimPsyNmeaPositionerStep::TestSingleNmeaRequestL()

    {

    CSimPsyMultiNmeaPosRequester* requester = CSimPsyMultiNmeaPosRequester::NewLC();

    TInt status;    

    TTimeIntervalMicroSeconds requestTime;

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

        {

		if (i <= 2) 

			{

			TPositionInfo position = TPositionInfo();    

			requester->MakeRequests(&position);

			requester->GetResult(status, requestTime);

			CheckRequestResultL(status, position);

			if (!&position)

				{

				User::Leave(KErrGeneral);

				}

			TPosition pos;			

			position.GetPosition(pos);

			TTime time = pos.Time();

			TDateTime dtime = time.DateTime();

			if (pos.Latitude() < 0 || pos.Longitude() < 0 || dtime.Year() < 2000)

				{

				User::Leave(KErrGeneral);

				}

			}

		else

			{

			HPositionGenericInfo* genposition = HPositionGenericInfo::NewLC();    

            User::LeaveIfError(genposition->SetRequestedField(EPositionFieldNMEASentences));

			requester->MakeRequests(genposition);

			requester->GetResult(status, requestTime); 

			CheckRequestResultL(status, *genposition);

			if (!&genposition && status == KErrNone)

				{

				User::Leave(KErrGeneral);

				}			

			TPosition genpos;			

			genposition->GetPosition(genpos);

			TTime time = genpos.Time();

			TDateTime dtime = time.DateTime();

			if (genpos.Latitude() < 0 || genpos.Longitude() < 0 || dtime.Year() < 2000)

				{

				User::Leave(KErrGeneral);

				}

            // Check that the burst starts with the same sentence all the time.

            // In the nmea test file, the first burst will be GLL.

            _LIT8(KExpectedFirstSentence, "$GPGLL");

            TPtrC8 firstNmeaString(NULL, 0);

            User::LeaveIfError(genposition->GetValue(EPositionFieldNMEASentencesStart, firstNmeaString));

            if (firstNmeaString.Left(6).Compare(KExpectedFirstSentence) != 0)

                {

                _LIT(KError, "Expected GPGLL sentence at the beginning of the burst");

                LogErrorAndFail(KError);

                }

			CleanupStack::PopAndDestroy(genposition);

			}

        }

    CleanupStack::PopAndDestroy(); // requester        

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

    INFO_PRINTF1(KSingleNmeaRequestTest);

    }

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

// CSimPsyNmeaPositionerStep::CancelSingleNmeaRequestL

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

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

//       

void CSimPsyNmeaPositionerStep::CancelSingleNmeaRequestL()

    {        

    CSimPsyMultiNmeaPosRequester* requester = CSimPsyMultiNmeaPosRequester::NewLC();

    requester->SetRequesterWillCancelL();

    TPositionInfo position = TPositionInfo();

    TInt status;

    TTimeIntervalMicroSeconds requestTime;

    requester->StopRequests();

    requester->MakeRequests(&position);

    requester->GetResult(status, requestTime);

    if (status != KErrCancel)

        {

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

        LogErrorAndFail(KReqWasNotCancelled);

        }

    CleanupStack::PopAndDestroy(requester); // requester  

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

	INFO_PRINTF1(KSingleNmeaCancelTest);

    }

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

// CSimPsyNmeaPositionerStep::TestMultipleNmeaCancelTestL

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

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

//       

void CSimPsyNmeaPositionerStep::TestMultipleNmeaCancelTestL(

    TBool aFirstWillCancel,

    TBool aSecondWillCancel,

    TBool aThirdWillCancel)

    {    

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

    if (aFirstWillCancel)

        {

        requester->SetRequesterWillCancelL(0);

        }

    if (aSecondWillCancel)

        {

        requester->SetRequesterWillCancelL(1);

        }

    if (aThirdWillCancel)

        {

        requester->SetRequesterWillCancelL(2);

        }

    TPositionInfo position = TPositionInfo();    

    TInt status;

    TTimeIntervalMicroSeconds requestTime;

    requester->MakeRequests(&position);

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

        {

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

        TBool shouldHaveCancelled = 

            (i == 0) ? aFirstWillCancel

            : (i == 1) ? aSecondWillCancel

            : aThirdWillCancel;

        if (shouldHaveCancelled)

            {

            if (status != KErrCancel)

                {

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

                LogErrorAndFail(KReqWasNotCancelled);

                }

			}

        else

            {

            if (status != KErrNone)

                {

                _LIT(KReqFailed, "The request failed");

                LogErrorAndFail(KReqFailed);

                }

            if (!&position)

                {

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

                LogErrorAndFail(KHasNoPosition);        

                }            

            }

        }

    CleanupStack::PopAndDestroy(); // requester    

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

	INFO_PRINTF1(KMultCancelTest);

    }

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

// CSimPsyNmeaPositionerStep::TestMultipleRequestsL

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

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

//       

void CSimPsyNmeaPositionerStep::TestMultipleRequestsL(TInt aNumberOfRequests)

    {

    CSimPsyMultiNmeaPosRequester* requester = CSimPsyMultiNmeaPosRequester::NewLC();

    TInt status;

    TPositionInfo position = TPositionInfo();        

    TTimeIntervalMicroSeconds requestTime;    

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

        {

        // RDebug::Print(_L("TestMultipleRequestsL making request"));

        requester->MakeRequests(&position);

        requester->GetResult(status, requestTime);   

		CheckRequestResultL(status, position);		

        }

    CleanupStack::PopAndDestroy(); // requester        

    requester = NULL;  

	_LIT(KMultipleRequestsMemoryTestName, "Ended: **** Multiple req memory leak test ****");

	INFO_PRINTF1(KMultipleRequestsMemoryTestName);

    }

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

// CSimPsyNmeaPositionerStep::TestMultipleRequestsAndCancelL

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

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

//      

void CSimPsyNmeaPositionerStep::TestMultipleRequestsAndCancelL(

    TInt aNumberOfRequests, TBool aFirstWillCancel,

    TBool aSecondWillCancel, TBool aThirdWillCancel)

    {    

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

    if (aFirstWillCancel)

        {

        requester->SetRequesterWillCancelL(0);

        }

    if (aSecondWillCancel)

        {

        requester->SetRequesterWillCancelL(1);

        }