/*

* Copyright (c) 2005-2006 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:  Tests GetSuplInfoL in various scenarios.

*

*/

#include <epos_comasuplposhandlerbase.h>

#include <epos_comasuplpossessionbase.h>

#include <epos_comasuplinforequestlist.h>

#include <epos_comasuplinforequestlist.h>

#include <epos_comasuplreqasstdata.h>

#include <epos_comasuplsetcapabilities.h>

#include <epos_comasuplposition.h>

#include <epos_comasuplpospayload.h>

#include <epos_comasuplvelocity.h>

#include <epos_eomasuplposerrors.h>

#include <ecom/ecom.h>

#include "epos_comasuplsessiontest.h"

#include "epos_comasuplpostesterlogger.h"

#include "epos_comasupltesthandler.h"

#include "epos_comasuplgetsuplinfomanager.h"

/** Constant used for logging information about test*/

_LIT8(KSessionTestComplete, "Info: Session Test Complete.");

/** Constant used for logging information about test*/

_LIT8(KSessionTestAborted, "Error: Session  Test Aborted");

/** Constant used for logging information about test*/

_LIT8(KReqBeforeSessionInitialize, "Info: Requesting GetSuplInfo before \

Initializing POS session.");

/** Constant used for logging information about test*/

_LIT8(KPositionReqBeforeSessionInitialize, "Info: Requesting GetPositionL\

 before initializing POS session.");

/** Constant used for logging information about test*/

_LIT8(KGetSuplInfoSessionEndRequest, "Info: GetPositionL requested after \

Session End.");

/** Constant used for logging information about test*/

_LIT8(KGetSuplInfoWarning, "Warning: POS session is Not initialized.\

GetSuplInfoL() completed with KErrNone.");

/** Constant used for logging information about test*/

_LIT8(KPosInactiveInfo, "Info: GetSuplInfoL() completed with status \

KErrOMASuplPosInActive");

/** Constant used for logging information about test*/

_LIT8(KGetSuplInfoInfo, "Info: GetSuplInfoL() completed with status \

KErrNone.");

/** Constant used for logging information about test*/

_LIT8(KGetPositionInfo, "Info: GetPositionL() completed with status ");

/** Constant used for logging information about test*/

_LIT8(KGetPositionWarn, "Warning: GetPositionL() completed with status ");

/** Constant used for logging information about test*/

_LIT8(KGetSuplError, "Error: GetSuplInfoL() completed with status ");

/** Constant used for logging information about test*/

_LIT8(KGetPositionError, "Error: GetPositionL() completed with status ");

/** Constant used for logging information about test*/

_LIT8(KGetPositionInfoErr, "Error: Could not provide value to some \

mandatory fields. GetPositionL() completed with status ");

/** Constant used for logging information about test*/

_LIT8(KRequestAfterSessionInit, "Info: Requesting GetSuplInfo after \

Initializing POS session.");

/** Constant used for logging information about test*/

_LIT8(KGetPositionSessionInitRequest, "Info: Requesting for GetPositionL().\

 Session is initialized.");

/** Constant used for logging information about test*/

_LIT8(KPositionEndSessionRequest, "Info: Requesting for GetPositionL() \

 after ending POS Session.");

/** Constant used for logging information about test*/

_LIT8(KEndSession, "Info: Ending POS Session.");

/** Constant used for logging information about test*/

_LIT8(KEndSessionComplete, "Info: Ending POS Session complete.");

/** Constant used for logging information about test*/

_LIT8(KExistingSessionTest, "Info: Running test on an existing session.");

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

// Named constructor

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

//

COMASuplSessionTest* COMASuplSessionTest::NewL(

								COMASuplPosHandlerBase& aPosHandler

							, COMASuplPosTesterCategory* aCallBack )

	{

	COMASuplSessionTest* self = new( ELeave )COMASuplSessionTest( 

									aPosHandler, aCallBack );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// Constructor

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

//

COMASuplSessionTest::COMASuplSessionTest(

							COMASuplPosHandlerBase& aPosHandler

							, COMASuplPosTesterCategory* aCallBack )

							:COMASuplGetSuplInfoManager(aPosHandler, aCallBack)

	{

	iSessionState = ESessionUninitialized;

	iExistingSessionTestDone = EFalse;

	CActiveScheduler::Add( this );

	}

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

// Second phase constructor

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

//

void COMASuplSessionTest::ConstructL()

	{

	iRequestList = COMASuplInfoRequestList::NewL();

	iPosition = COMASuplPosition::NewL();

	}

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

// Destructor

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

//

COMASuplSessionTest::~COMASuplSessionTest()

	{

	delete iPosition;

	}

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

// This function is called by test handler. It is entry point of execution

// of a test case.

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

//

void COMASuplSessionTest::StartTestingL()

	{

	if(iCallBack)

		{

		iLogger->WriteTestHeader(KSessionTest, iTestNo);

		}

	iNextInSeq = EStartTest;

	__ASSERT_ALWAYS(!IsActive(),User::Panic(KPanicSetActive, KErrAlreadyExists));

	DummyRequest(iStatus);

	SetActive();

	}

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

// Handles an active object's request completion event.

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

//

void COMASuplSessionTest::RunL()

	{

	switch( iNextInSeq )

		{

		case EStartTest:

			{

			iLogger->GetRequestStartTime();

			TRAPD( err, iSessionBase = iPosHandler.CreateNewSessionL( this ) );

			if( KErrNone != err )

				{

				iError++;

				iLogger->WriteLine(KCreatingSessionFail, iTestNo);

				User::Leave(err);

				}

			iInfo++;

			iLogger->LogExecutionTime(KExecCreateNewSessionL);

			iInfo++;

			iLogger->WriteLine(KSessionCreated, iTestNo);

			__ASSERT_ALWAYS(!IsActive(),User::Panic(KPanicSetActive, KErrAlreadyExists));

			iNextInSeq = EGetSuplInfoSessionNotInitRequest;

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case EGetSuplInfoSessionNotInitRequest:

			{

			iInfo++;

			iLogger->WriteLine(KReqBeforeSessionInitialize, iTestNo);

			iNextInSeq = EGetSuplInfoSessionNotInitRequestComplete;

			GetSuplInfoRequestL();

			break;

			}

		case EGetSuplInfoSessionNotInitRequestComplete:

			{

			iNextInSeq = EGetPositionSessionNotInitRequest;

			GetSuplInfoRequestCompleteL();

			__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case EGetPositionSessionNotInitRequest:

			{

			iNextInSeq = EGetPositionSessionNotInitRequestComplete;

			iInfo++;

			iLogger->WriteLine(KPositionReqBeforeSessionInitialize, iTestNo);

			GetPositionRequestL();

			break;

			}

		case EGetPositionSessionNotInitRequestComplete:

			{

			iNextInSeq = EInitializeSessionRequest;

			GetPositionRequestComplete();

			__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case EInitializeSessionRequest:

			{

			iNextInSeq = EinitializeSessionRequestComplete;

			iInfo++;

			iLogger->WriteLine(KInitializingSession, iTestNo);

			InitializeSessionRequestL();

			break;

			}

		case EinitializeSessionRequestComplete:

			{

			iNextInSeq = EGetSuplInfoSessionInitRequest;

			InitializeSessionRequestCompleteL();

			break;

			}

		case EGetSuplInfoSessionInitRequest:

			{

			iNextInSeq = EGetSuplInfoSessionInitRequestComplete;

			//log "Info: Requesting for GetSuplInfoL(). Session is initialized."

			iInfo++;

			iLogger->WriteLine(KRequestAfterSessionInit, iTestNo);

			GetSuplInfoRequestL();

			break;

			}

		case EGetSuplInfoSessionInitRequestComplete:

			{

			iNextInSeq = EGetPositionSessionInitRequest;

			GetSuplInfoRequestCompleteL();

			__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case EGetPositionSessionInitRequest:

			{

			iNextInSeq = EGetPositionSessionInitRequestComplete;

			iInfo++;

			iLogger->WriteLine(KGetPositionSessionInitRequest, iTestNo);

			GetPositionRequestL();

			break;

			}

		case EGetPositionSessionInitRequestComplete:

			{

			iNextInSeq = EEndSessionRequest;

			GetPositionRequestComplete();

			__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case EEndSessionRequest:

			{

			iNextInSeq = EEndSessionRequestComplete;

			//log "Info: Ending POS session."

			iInfo++;

			iLogger->WriteLine(KEndSession, iTestNo);

			EndSession();

			__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case EEndSessionRequestComplete:

			{

			iNextInSeq = EGetSuplInfoSessionEndRequest;

			//log "Info: POS Session Ended."

			iInfo++;

			iLogger->WriteLine(KEndSessionComplete, iTestNo);

			__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case EGetSuplInfoSessionEndRequest:

			{

			iNextInSeq = EGetSuplInfoSessionEndRequestComplete;

			//log "Requesting for GetSuplInfoL(). Session is ended."

			iInfo++;

			iLogger->WriteLine(KGetSuplInfoSessionEndRequest, iTestNo);

			GetSuplInfoRequestL();

			break;

			}

		case EGetSuplInfoSessionEndRequestComplete:

			{

			iNextInSeq = EGetPositionSessionEndRequest;

			GetSuplInfoRequestCompleteL();

			__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case EGetPositionSessionEndRequest:

			{

			iNextInSeq = EGetPositionSessionEndRequestComplete;

			iInfo++;

			iLogger->WriteLine(KPositionEndSessionRequest, iTestNo);

			GetPositionRequestL();

			break;

			}

		case EGetPositionSessionEndRequestComplete:

			{

			iNextInSeq = EExistingSessionTest;

			GetPositionRequestComplete();

			__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case EExistingSessionTest:

			{

			if(iExistingSessionTestDone)

				{

				iNextInSeq = ETestingComplete;

				}

			else

				{

				iExistingSessionTestDone = ETrue;

				iInfo++;

				iLogger->WriteLine(KExistingSessionTest, iTestNo);

				iNextInSeq = EInitializeSessionRequest;

				}

			__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

			DummyRequest(iStatus);

			SetActive();

			break;

			}

		case ETestingComplete:

			{

			TestingComplete(KSessionTestComplete);

			break;

			}

		}

	}

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

// Implements cancellation of an outstanding request.

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

//

void COMASuplSessionTest::DoCancel()

	{

	if(EGetSuplInfoSessionNotInitRequestComplete == iNextInSeq

		|| EGetSuplInfoSessionInitRequestComplete == iNextInSeq

		||EGetSuplInfoSessionEndRequestComplete == iNextInSeq)

		{

		//Cancel GetSuplInfoL()

		iSessionBase->CancelSuplInfoRequest();

		}

	if(EGetPositionSessionNotInitRequestComplete == iNextInSeq

	 || EGetPositionSessionInitRequestComplete == iNextInSeq

	 || EGetPositionSessionEndRequestComplete == iNextInSeq)

		{

		// Cancel GetPositionL()

		iSessionBase->CancelGetPosition();

		}

	if(EinitializeSessionRequestComplete == iNextInSeq)

		{

		//Cancel session initialization

		iSessionBase->CancelInitialize();

		}

	}

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

// Handles a leave occurring in the request completion event handler RunL().

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

//

TInt  COMASuplSessionTest::RunError( TInt aError )

	{

	if(EStartTest == iNextInSeq)

		{

		iError++;

		iLogger->WriteStatus(KLeaveInCreateNewSession, aError, iTestNo);

		}

	else if(EGetSuplInfoSessionNotInitRequestComplete == iNextInSeq

		|| EGetSuplInfoSessionInitRequestComplete == iNextInSeq

		||EGetSuplInfoSessionEndRequestComplete == iNextInSeq)

		{

		//Cancel GetSuplInfoL()

		iError++;

		iLogger->WriteStatus(KLeaveInGetSuplInfo, aError, iTestNo);

		}

	else if(EGetPositionSessionNotInitRequestComplete == iNextInSeq

	 || EGetPositionSessionInitRequestComplete == iNextInSeq

	 || EGetPositionSessionEndRequestComplete == iNextInSeq)

		{

		// Cancel GetPositionL()

		iError++;

		iLogger->WriteStatus(KLeaveInGetPosition, aError, iTestNo);

		}

	else if(EinitializeSessionRequestComplete == iNextInSeq)

		{

		//Cancel session initialization

		iError++;

		iLogger->WriteStatus(KLeaveInSessionInit, aError, iTestNo);

		}

	TestingAborted(KSessionTestAborted);

	return KErrNone;

	}

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

// Requests for GetSuplInfoL.

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

//

void COMASuplSessionTest::GetSuplInfoRequestL()

	{

	ResetLists();

	TRAPD(err, CreateRequestListL());

	if(KErrNone != err)

		{

		iError++;

		iLogger->WriteStatus(KLeaveRequestListCreation(), err, iTestNo);

		TestingAborted(KSessionTestAborted);

		return;

		}

	__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

	iSessionBase->GetSuplInfoL(iRequestList, iStatus);

	SetActive();

	}

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

// Logs the completion status of GetsuplinfoL.

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

//

void COMASuplSessionTest::GetSuplInfoRequestCompleteL()

	{

	TInt diff = -1;

	if(!MatchLists(diff))

		{

		iError++;

		iLogger->WriteStatus(KMatchError, diff, iTestNo, &KNULL());

		}

	switch (iStatus.Int())

		{

		case KErrNone:

			{

			if(ESessionInitialized == iSessionState)

				{

				//info

				iInfo++;

				iLogger->WriteLine(KGetSuplInfoInfo, iTestNo);

				}

			else 

				{

				//warning

				iWarning++;

				iLogger->WriteLine(KGetSuplInfoWarning, iTestNo);

				}

			iLogger->LogRequestList(*iRequestList);

			break;

			}

		case KErrOMASuplPosInActive:

			{

			if(ESessionInitialized == iSessionState)

				{

				//warning

				iWarning++;

				iLogger->WriteLine(_L8("Warning: GetSuplInfo completed with status KErrNone. Session is initialized."), iTestNo);

				}

			else 

				{

				//info

				iInfo++;

				iLogger->WriteLine(KPosInactiveInfo, iTestNo);

				}

			break;

			}

		case KErrOMASuplParamNotSet:

			{

			//warning

			iWarning++;

			iLogger->WriteLine(_L8("Warning: Parameter not set."), iTestNo);

			iLogger->LogRequestList(*iRequestList);

			break;

			}

		default:

			{

			//Error

			iWarning++;

			iLogger->WriteStatus(KGetSuplError(), iStatus.Int(), iTestNo

												, &KNULL());

			break;

			}

		}

	}

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

// Initializes the POS session.

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

//

void COMASuplSessionTest::InitializeSessionRequestL()

	{

	__ASSERT_ALWAYS( !IsActive(), User::Panic(KPanicSetActive, 1));

	// Set the status as session is initialized.

	iSessionState = ESessionInitialized;

	iSessionBase->InitializeL(iRequestID, iStatus);

	SetActive();

	}

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

// Logs the completion status of session initialization.