/**

* 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 "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:

*

*/

/**

 @file ConnectionServer.TestSteps.h

*/

#if (!defined CONNECTIONSERVER_TESTSTEPS_H)

#define CONNECTIONSERVER_TESTSTEPS_H

#include <test/testexecutestepbase.h>

#include "Te_EsockStepBase.h"

#include <comms-infras/es_connectionserv.h>

#include <comms-infras/cs_connservparams.h>

//#include <comms-infras/connservwifiparams.h>

#include <networking/mbmsparams.h>

#include <networking/qos3gpp_subconparams.h>

#include <genericscprparams.h>

#include <comms-infras/es_availability.h>

#include <etelmm.h>

_LIT(KConnectionServName, "ConnServName");

_LIT(KConnectionServTierId, "TierId");

// Test step classes

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

/**

Class implementing CreateRConnectionServStep

@internalComponent

*/

class CCreateRConnectionServStep : public CTe_EsockStepBase

	{

public:

	CCreateRConnectionServStep(CCEsockTestBase*& aEsockTest);

	TVerdict doTestStepPreambleL();

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	TPtrC iConnectionServName;

	};

_LIT(KCreateRConnectionServStep, "CreateRConnectionServStep");

/**

Class implementing CConnectRConnectionServStep

@internalComponent

*/

class CConnectRConnectionServStep : public CTe_EsockStepBase

	{

public:

	CConnectRConnectionServStep(CCEsockTestBase*& aEsockTest);

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

	TInt TierNameToTierId(const TDesC& aTierName, TUint& aTierId);

private:

	TPtrC iConnectionServName;

	TUint iTierId;

	};

_LIT(KConnectRConnectionServStep, "ConnectRConnectionServStep");

/**

Class implementing CRConnectionServApiExtStep

@internalComponent

*/

class CRConnectionServApiExtStep : public CTe_EsockStepBase

	{

public:

	CRConnectionServApiExtStep(CCEsockTestBase*& aEsockTest);

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	RCommsDataMonitoringApiExt iExt;

	TPtrC iConnectionServName;

	TUint iTierId;

	};

_LIT(KRConnectionServApiExtStep, "RConnectionServApiExtStep");

/**

Class implementing CCloseRConnectionServStep

@internalComponent

*/

class CCloseRConnectionServStep : public CTe_EsockStepBase

	{

public:

	CCloseRConnectionServStep(CCEsockTestBase*& aEsockTest);

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	TPtrC iConnectionServName;

	};

_LIT(KCloseRConnectionServStep, "CloseRConnectionServStep");

class TExpectedAccessPointStatusMask : public ConnectionServ::TAccessPointStatusFilter

	{

public:

	TBool CompareToAPStatus(const ConnectionServ::TAccessPointStatus& aStatus) const;

private:

	TBool CompareStatusFlagToMaskFlag(

		const ConnectionServ::TAccessPointFlagValue apFlag,

		const ConnectionServ::TAccessPointFlagFilterValue apMaskValue) const;

	};

class TExpectedAccessPointParameters

	{

public:

	TExpectedAccessPointParameters(

		const TAccessPointInfo& aInfo,

		const TExpectedAccessPointStatusMask& aStatus)

			: iInfo(aInfo), iStatus(aStatus) {}

	const TExpectedAccessPointStatusMask& AccessPointStatus() const {return iStatus;}

	const TAccessPointInfo& AccessPointInfo() const {return iInfo;}

private:

	TAccessPointInfo iInfo;

	TExpectedAccessPointStatusMask iStatus;

	};

/**

Base class for query based RConnectionServ tests

@internalComponent

*/

class CRConnectionServQueryTestStepBase : public CTe_EsockStepBase

	{

public:

	CRConnectionServQueryTestStepBase(CCEsockTestBase*& aEsockTest) : CTe_EsockStepBase(aEsockTest) {}

protected:

	void BundleToString(const CParameterBundleBase* aBundle, TDes& aBuf);

	void ParamSetCtrToString(const CParameterSetContainer* aCtnr,TDes& aBuf);

	void GenericParamsToString(const ConnectionServ::XAccessPointGenericParameterSet* aSet, TDes& aBuf);

	//void WifiParamsToString(const ConnectionServ::XAccessPointWifiParameterSet* aSet, TDes& aBuf);

	void MBMSParamsToString(const ConnectionServ::XMBMSServiceQuerySet* aSet,

			TDes& aBuf);

	void MBMSServiceParamsToString(const ConnectionServ::XMBMSServiceParameterSet* aSet,

				TDes& aBuf); 

	TChar GetApFlagChar(ConnectionServ::TAccessPointFlagValue val);

	TInt BuildQueryL(ConnectionServ::CConnectionServParameterBundle& aQueryBundle);

	TInt BuildExpectedResultsL(

		RArray<TExpectedAccessPointParameters>& aExpectedAPParameters,

		TInt& aNumExpectedAPs);

	void FetchFilterL(const TDesC& aFilterDes, ConnectionServ::TAccessPointStatusFilter& aFetchedFilter);

	ConnectionServ::TAccessPointFlagFilterValue ReadFlagFilterValueL(TChar ch);

	TBool CompareAgainstExpected(

		TInt aNumExpected,

		RArray<TExpectedAccessPointParameters>& aAPsExpected,

		ConnectionServ::CConnectionServParameterBundle& aResultsBundle);

	};

/**

Class implementing CAccessPointStatusQueryStep

@internalComponent

*/

class CAccessPointStatusQueryStep : public CRConnectionServQueryTestStepBase

	{

public:

	CAccessPointStatusQueryStep(CCEsockTestBase*& aEsockTest);

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	~CAccessPointStatusQueryStep();

	TPtrC iConnectionServName;

	ConnectionServ::CConnectionServParameterBundle*	iQueryBundle;

	ConnectionServ::CConnectionServParameterBundle*	iResultsBundle;

	TInt iExpectedError;

	TInt iNumExpectedAPs;

	RArray<TExpectedAccessPointParameters> iExpectedAPParameters;

	};

_LIT(KAccessPointStatusQueryStep, "AccessPointStatusQueryStep");

/**

Class implementing CCancelAccessPointStatusQueryStep

@internalComponent

*/

class CCancelAccessPointStatusQueryStep : public CRConnectionServQueryTestStepBase

	{

public:

	CCancelAccessPointStatusQueryStep(CCEsockTestBase*& aEsockTest);

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	~CCancelAccessPointStatusQueryStep();

	TPtrC iConnectionServName;

	ConnectionServ::CConnectionServParameterBundle*	iQueryBundle;

	ConnectionServ::CConnectionServParameterBundle*	iResultsBundle;

	TInt iNumExpectedAPs;

	RArray<TExpectedAccessPointParameters> iExpectedAPParameters;

	};

_LIT(KCancelAccessPointStatusQueryStep, "CancelAccessPointStatusQueryStep");

/**

Class implementing CRequestAccessPointNotification

@internalComponent

*/

class CRequestAccessPointNotificationStep : public CRConnectionServQueryTestStepBase

	{

public:

	CRequestAccessPointNotificationStep(CCEsockTestBase*& aEsockTest);

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	TPtrC iConnectionServName;

	TPtrC iNotifName;

	ConnectionServ::CConnectionServParameterBundle*	iQueryBundle;

	ConnectionServ::CConnectionServParameterBundle*	iResultsBundle;

	TInt iExpectedError;

	TInt iNumExpectedAPs;

	RArray<TExpectedAccessPointParameters> iExpectedAPParameters;

	};

_LIT(KRequestAccessPointNotificationStep, "RequestAccessPointNotificationStep");

/**

Class implementing CReceiveAccessPointNotification

@internalComponent

*/

class CReceiveAccessPointNotificationStep : public CRConnectionServQueryTestStepBase

	{

public:

	CReceiveAccessPointNotificationStep(CCEsockTestBase*& aEsockTest);

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	TPtrC iConnectionServName;

	TPtrC iNotifName;

	RArray<TExpectedAccessPointParameters> iExpectedAPParameters;

	TInt iNumExpectedAPs;

	TInt iInitialDelayInSeconds;

	TBool iExpectingNotification;

	};

_LIT(KReceiveAccessPointNotificationStep, "ReceiveAccessPointNotificationStep");

/**

Class implementing CCancelAccessPointNotification

@internalComponent

*/

class CCancelAccessPointNotificationStep : public CRConnectionServQueryTestStepBase

	{

public:

	CCancelAccessPointNotificationStep(CCEsockTestBase*& aEsockTest);

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	TPtrC iNotifName;

	TInt iInitialDelayInSeconds;

	};

_LIT(KCancelAccessPointNotificationStep, "CancelAccessPointNotificationStep");

class MObserverTimeout

	{

public:

	virtual void Timeout() = 0;

	};

// CConnServNotificationWatcher

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

class CConnServNotificationWatcher :

	public CBase,

	public ConnectionServ::MAccessPointNotificationObserver

	{

public:

	// Thread entry point

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

	static TInt EntryPoint(TAny* aArgs);

	void RunNotificationL();

	CConnServNotificationWatcher(ConnectionServ::RConnectionServ* aConnServ)

		: iConnServ(*aConnServ) {}

	static CConnServNotificationWatcher* NewLC(

		ConnectionServ::RConnectionServ* aConnServ,

		ConnectionServ::CConnectionServParameterBundle* aQueryBundle);

	void ConstructL(ConnectionServ::CConnectionServParameterBundle* aQueryBundle);

	// MAccessPointNotificationObserver

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

	virtual void AccessPointNotification(ConnectionServ::CConnectionServParameterBundle* aResult);

	virtual void AccessPointNotificationError(TInt aErrCode);

	void Wait() {iMutex.Wait();}

	void Signal() {iMutex.Signal();}

	void AwaitStartupCompletionL() const;

	void WaitOnQueueL() const;

	void PerformNotificationRequestL();

	ConnectionServ::CConnectionServParameterBundle* GetResultsBundle();

	void CancelNotification();

	TInt ErrCode() const { return iErrCode; }

	void DoCancel();

	~CConnServNotificationWatcher();

private:

	TInt iErrCode;

	ConnectionServ::RConnectionServ iConnServ;

	ConnectionServ::CConnectionServParameterBundle* iQueryBundle;

	RPointerArray<ConnectionServ::CConnectionServParameterBundle> iNotificationBundles;

	TInt iTimeout;

	RMutex iMutex;

	RProperty iQueueProp;

	TBool iHaveReceivedNotifSetupAck;

public:

	RThread iNotifThread;

	RThread iCommandThread;

	TRequestStatus* iCancelStatus;

	};

// CNotifCancelControl

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

class CNotifCancelControl : public CActive

	{

public:

	CNotifCancelControl(CConnServNotificationWatcher& aNotifMgr)

		: iNotifManager(aNotifMgr), CActive(EPriorityStandard) {}

	static CNotifCancelControl* NewL(CConnServNotificationWatcher& aNotifMgr)

		{

		CNotifCancelControl* mine = new(ELeave) CNotifCancelControl(aNotifMgr);

		CActiveScheduler::Add(mine);

		return mine;

		}

	void Wait()

		{

		iStatus = KRequestPending;

		SetActive();

		iNotifManager.iCancelStatus = &iStatus;

		}

private:

	void DoCancel() {}

	void RunL()

		{

		// Stop the active scheduler which will cancel all outstanding requests

		CActiveScheduler::Stop();

		}

private:

	CConnServNotificationWatcher& iNotifManager;

	};

/**

Class implementing CSetAccessPointAvailabilityStep

@internalComponent

@description Enables the setting of availability status on access points for simulation of availability

*/

class CSetAccessPointAvailabilityStep : public CTe_EsockStepBase

	{

public:

	CSetAccessPointAvailabilityStep(CCEsockTestBase*& aEsockTest);

	TVerdict doTestStepPreambleL();

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	TInt iAccessPointId;

	TInt iAvailabilityScore;

	};

_LIT(KSetAccessPointAvailabilityStep, "SetAccessPointAvailabilityStep");

/**

Class implementing CSetPppAccessPointAvailabilityStep

@internalComponent

@description Enables the setting of Ppp availability status on access points for simulation of availability

*/

class CSetPppAccessPointAvailabilityStep : public CTe_EsockStepBase

	{

public:

	CSetPppAccessPointAvailabilityStep(CCEsockTestBase*& aEsockTest);

	TVerdict doTestStepPreambleL();

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	RMobilePhone::TMobilePhoneRegistrationStatus iRegStatus;

	};

_LIT(KSetPppAccessPointAvailabilityStep, "SetPppAccessPointAvailabilityStep");

/**

Class implementing CSetPacketDataAccessPointAvailabilityStep

@internalComponent

@description Enables the setting of PDP availability status on access points for simulation of availability

*/

class CSetPacketDataAccessPointAvailabilityStep : public CTe_EsockStepBase

    {

public:

    CSetPacketDataAccessPointAvailabilityStep(CCEsockTestBase*& aEsockTest);

    TVerdict doTestStepPreambleL();

    TVerdict doSingleTestStep();

    TInt ConfigureFromIni();

private:

    TBool iSetToAvailable;

    };

_LIT(KSetPacketDataAccessPointAvailabilityStep, "SetPacketDataAccessPointAvailabilityStep");

/**

Class implementing CSetWifiAccessPointAvailabilityStep

@internalComponent

@description Enables the setting of Ppp availability status on access points for simulation of availability

*/

class CSetWifiAccessPointAvailabilityStep : public CTe_EsockStepBase

	{

public:

	CSetWifiAccessPointAvailabilityStep(CCEsockTestBase*& aEsockTest);

	TVerdict doTestStepPreambleL();

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();

private:

	TInt	iAPAvailable;

	TPtrC	iSsid;

	TPtrC	iBssid;

	TPtrC	iSupportedRates;

	TPtrC	iNetworkType;

	TPtrC	iAuthenticated;

	TPtrC	iEncrypt;

	TPtrC	iAPEncryptionType;

	TPtrC	iAssociated;

	TPtrC	iChannel;

	TPtrC	iRssi;

	};

_LIT(KSetWifiAccessPointAvailabilityStep, "SetWifiAccessPointAvailabilityStep");

// Changes for MBMS Broadcast related test cases starts here 

enum TTypeOfNotification

		{

		EMbmsBearerAvailNtfn =1,

		EMbmsServiceAvailNtfn,

		EMbmsRemoveServiceNtfn,

		EMbmsActiveListNtfn,

		EMbmsMonitorListNtfn

		};

_LIT(KRequestMBMSNtfnStep, "RequestMBMSNtfnStep");

_LIT(KReceiveMBMSNtfnStep, "ReceiveMBMSNtfnStep");

_LIT(KCancelMBMSNtfnStep, "CancelMBMSNtfnStep");

/**

Class implementing CRequestMBMSNtfnStep

@internalComponent

*/

class CRequestMBMSNtfnStep : public CRConnectionServQueryTestStepBase

	{

public:

	CRequestMBMSNtfnStep(CCEsockTestBase*& aEsockTest);

	TVerdict doSingleTestStep();

	TInt ConfigureFromIni();