/*
* 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 cancellation of GetSuplInfoL()
*
*/


#include <epos_comasuplposhandlerbase.h>
#include <epos_comasuplpossessionbase.h>
#include <epos_comasuplinforequestlist.h>
#include <epos_comasuplinforequestlist.h>
#include <epos_comasuplreqasstdata.h>
#include <epos_comasuplinforequestlist.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_comasuplpostesterlogger.h"
#include "epos_comasupltesthandler.h"

#include "epos_comasuplgetsuplinfocanceltest.h"
#include "epos_comasuplpossessioncreationtest.h"
#include "epos_comasuplgetsuplinfomanager.h"


_LIT8(CancelNoInitialize, "Info: Calling Cancel of GetSuplInfoL before \
Initializing session and calling GetSuplInfoL.");

_LIT8(CancelNoGetSuplInfo, "Info: Calling Cancel of GetSuplInfoL before \
calling GetSuplInfoL.");

_LIT8(CancelGetSuplInfo, "Info: Calling Cancel of GetSuplInfoL after calling\
 GetSuplInfoL.");

_LIT8(CancelGetSuplInfoAgain, "Info: Calling Cancel of GetSuplInfoL after \
canceling GetSuplInfoL.");

_LIT8(CancelAfterEndSession, "Info: Calling Cancel of GetSuplInfoL after \
ending session.");

_LIT8(KCancelSuccess, "Info: GetSuplInfoL() canceled successfully.");

_LIT8(KCompNoneW, "Warning:GetSuplInfoL completed with KErrNone.");
_LIT8(KCompInActive,
	"Warning: GetSuplInfoL completed with KErrOMASuplPosInActive.");

_LIT8(KCompPosInfoW,
		"Warning:GetSuplInfoL completed with KErrOMASuplPosInfo.");

// ---------------------------------------------------------------------------
// Named constructor
// ---------------------------------------------------------------------------
//	
COMASuplGetSuplInfoCancelTest* COMASuplGetSuplInfoCancelTest::NewL(
								COMASuplPosHandlerBase& aPosHandler
								, COMASuplPosTesterCategory* aCallBack )
	{
	COMASuplGetSuplInfoCancelTest* self 
					= new( ELeave )COMASuplGetSuplInfoCancelTest(
							aPosHandler
							, aCallBack);
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop( self );
	return self;
	}

// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
COMASuplGetSuplInfoCancelTest::COMASuplGetSuplInfoCancelTest(
							COMASuplPosHandlerBase& aPosHandler
							, COMASuplPosTesterCategory* aCallBack )
						:COMASuplGetSuplInfoManager(aPosHandler, aCallBack)
							
	{
	CActiveScheduler::Add( this );
	}

// ---------------------------------------------------------------------------
// Second phase constructor
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::ConstructL()
	{
	iRequestList = COMASuplInfoRequestList::NewL();
	}

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
COMASuplGetSuplInfoCancelTest::~COMASuplGetSuplInfoCancelTest()
	{
	
	}

// ---------------------------------------------------------------------------
// Ends a POS Session.
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::EndSession(const TDesC8& aInfo)
	{
	iInfo++;
	iLogger->WriteLine(aInfo, iTestNo);
	iSessionBase->SessionEnd();
	}

// ---------------------------------------------------------------------------
// CancelSuplInfoRequest() is called without giving any GetSuplInfoL request.
// It is used for canceling GetSuplInfoL when request is not given.
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::CancelWithoutRequest( TRequestStatus& aStatus, 
											TExecutionSequence aNextinSeq)
	{
	CancelGetInfoRequest(CancelNoGetSuplInfo);
	iInfo++;
	iLogger->WriteLine( _L8( "Info: Cancellation without Request." ) , iTestNo);
	iNextInSeq = aNextinSeq;
	DummyRequest( aStatus );
	}

// ---------------------------------------------------------------------------
// CancelSuplInfoRequest() is called without giving any GetSuplInfoL request.
// It is used for canceling GetSuplInfoL only when request is given.
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::CancelGetInfoRequest(const TDesC8& aInfo)
	{
	iInfo++;
	iLogger->WriteLine(aInfo, iTestNo);
	iSessionBase->CancelSuplInfoRequest();
	}

// ---------------------------------------------------------------------------
// This function is called by test handler. It is entry point of execution
// of a test case.
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::StartTestingL()
	{
	if(iCallBack)
		{
		iLogger->WriteTestHeader(KGetSuplInfoCancelTest, iTestNo);
		}
	iNextInSeq = EStartTest;
	__ASSERT_ALWAYS(!IsActive(),User::Panic(KPanicSetActive, KErrAlreadyExists));
	DummyRequest(iStatus);
	SetActive();
	}

// ---------------------------------------------------------------------------
// Writes log based on completion status of GetSuplInfoL().
// ---------------------------------------------------------------------------
//

void COMASuplGetSuplInfoCancelTest::ProcessRequestComplete()
	{
	switch(iStatus.Int())
		{
		case KErrOMASuplPosInfo:
			{
			iWarning++;
			iLogger->WriteLine(KCompPosInfoW, iTestNo);
			break;
			}
		case KErrOMASuplPosInActive:
			{
			iWarning++;
			iLogger->WriteLine(KCompInActive, iTestNo);
			break;
			}
		case KErrNone:
			{
			iWarning++;
			iLogger->WriteLine(KCompNoneW, iTestNo);
			break;
			}
		case KErrCancel:
			{
			iInfo++;
			iLogger->WriteLine(KCancelSuccess, iTestNo);
			break;
			}
		default:
			{
			iError++;
			iLogger->WriteStatus(_L8( "Error:GetSuplInfoL \
completed with " ), iStatus.Int(), iTestNo);
			break;
			}
		}
	iLogger->LogRequestList(*iRequestList);
	}

// ---------------------------------------------------------------------------
// Handles an active object's request completion event.
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::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);
			//Cancel the request before initializing the session and giving
			//any request.
			CancelGetInfoRequest(CancelNoInitialize);
			iNextInSeq = EInitializeSession;
			iInfo++;
			__ASSERT_ALWAYS(!IsActive(),User::Panic(KPanicSetActive, KErrAlreadyExists));
			DummyRequest( iStatus );
			SetActive();
			break;
			}
		case EInitializeSession:
			{
			iNextInSeq = EInitializationComplete;
			iInfo++;
			iLogger->WriteLine(KInitializingSession, iTestNo);
			__ASSERT_ALWAYS(!IsActive(),User::Panic(KPanicSetActive, KErrAlreadyExists));
			iSessionBase->InitializeL( iRequestID, iStatus );
			SetActive();
			break;
			}
		case EInitializationComplete:
			{
			ProcessInitComplete();
			break;
			}
		case ERequestGetSuplInfoAndCancel:
			{
			ProcessGetSuplInfoAndCancelL();
			break;
			}
		case EGetSuplInfoLRequestComplete:
			{
			ProcessGetSuplInfoRequestComplete();
			break;
			}
		case EEndSessionAndCancel:
			{
			ProcessEndSessionAndCancel();
			break;
			}
		case ETestingComplete:
			{
			TestingComplete(KGetSuplInfoCancelTestComplete);
			break;
			}
		default:
			{
			User::Leave(KErrGeneral);
			}
		}
	}
	
// ---------------------------------------------------------------------------
// Implements cancellation of an outstanding request.
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::DoCancel()
	{
	if( iNextInSeq == EInitializationComplete)
		{
		iSessionBase->CancelInitialize();
		}
	}

// ---------------------------------------------------------------------------
// Handles a leave occurring in the request completion event handler RunL().
// ---------------------------------------------------------------------------
//
TInt COMASuplGetSuplInfoCancelTest::RunError( TInt aError )
	{
	if(EStartTest == iNextInSeq)
		{
		//Leave in initialization
		iError++;
		iLogger->WriteStatus(KLeaveInCreateNewSession, aError, iTestNo);
		}
	if(EInitializationComplete == iNextInSeq)
		{
		//Leave in initialization
		iError++;
		iLogger->WriteStatus(KLeaveInSessionInit, aError, iTestNo);
		}
	if(EGetSuplInfoLRequestComplete == iNextInSeq)
		{
		//Leave in GetSuplInfoL
		iError++;
		iLogger->WriteStatus(KLeaveInGetSuplInfo, aError, iTestNo);
		}
	TestingAborted(KGetSuplInfoCancelTestAborted);
	return KErrNone;
	}

// ---------------------------------------------------------------------------
// If Session initialization completes with KErrNone, calls CancelGetSuplInfo
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::ProcessInitComplete()
	{
	if(iStatus == KErrNone)
		{
		iInfo++;
		iLogger->WriteLine(KSessionInitialized, iTestNo);
		__ASSERT_ALWAYS( !IsActive(),
						User::Panic( KPanicSetActive, 1 ) );
		CancelWithoutRequest(iStatus, ERequestGetSuplInfoAndCancel );
		SetActive();
		}
	else
		{
		iError++;
		iLogger->WriteStatus(KError, iStatus.Int(), iTestNo, &KSessionInitResult());
		TestingAborted(KGetSuplInfoCancelTestAborted);
		}				
	}


// ---------------------------------------------------------------------------
// Requests for GetSuplInfoL() and immediately cancels it.
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::ProcessGetSuplInfoAndCancelL()
	{
	__ASSERT_ALWAYS( !IsActive(), User::Panic( KPanicSetActive, 1 ) );
	iNextInSeq = EGetSuplInfoLRequestComplete;
	iInfo++;
	iLogger->WriteLine(_L8("Info: Requesting GetSuplInfoL"), iTestNo);
	iSessionBase->GetSuplInfoL( iRequestList, iStatus );
	SetActive();
	CancelGetInfoRequest(CancelGetSuplInfo);
	}

// ---------------------------------------------------------------------------
// When GetSuplInfoL completes this function is executed. It provides 
// information about completion status of GetSuplInfoL.
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::ProcessGetSuplInfoRequestComplete()
	{
	TInt diff = -1;
	if(!MatchLists(diff))
		{
		iError++;
		iLogger->WriteStatus(KMatchError, diff, iTestNo, &KNULL());
		}
	ProcessRequestComplete();
	CancelGetInfoRequest(CancelGetSuplInfoAgain);
	iNextInSeq = EEndSessionAndCancel;
	__ASSERT_ALWAYS( !IsActive(), User::Panic( KPanicSetActive, 1 ) );
	DummyRequest( iStatus );
	SetActive();
	}

// ---------------------------------------------------------------------------
// Ends session specified by iSessionBase and requests for CancelGetsuplInfo.
// ---------------------------------------------------------------------------
//
void COMASuplGetSuplInfoCancelTest::ProcessEndSessionAndCancel()
	{
	EndSession(KSessionEnd);
	CancelGetInfoRequest(CancelAfterEndSession);
	__ASSERT_ALWAYS( !IsActive(), User::Panic( KPanicSetActive, 1 ) );
	iNextInSeq = ETestingComplete;
	DummyRequest( iStatus );
	SetActive();
	}