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

// Definition of BCA Test Proxy

// The proxy encapsulates test logging and error checking.

// 

//

/**

 @file

*/

#ifndef BCATESTPROXY_H

#define BCATESTPROXY_H

#include <networking\bca.h>

#include <networking\bcaFactory.h>

using namespace BasebandChannelAdaptation;

#include <E32Base.h>

#include <E32std.h>

#include <test/TestExecuteStepBase.h>

/** Encapsulates all xxBca tests */

namespace te_xxBcaUnitTests

	{

	// BCA factory function 

	typedef MBcaFactory* (*TNewBcaFactoryProcL)(void);

	typedef TAutoClose<RLibrary> TDllAutoClose;

		/**

	Async request handler */

	class CExecutor: public CActive

		{

		public:

			CExecutor(MBca& iBca);

			virtual ~CExecutor();

			void Exec();

			void RunL();

			void ForceCompletion(TInt aErr);

			TInt CompletionError();			

			virtual void DoCancel();

		protected:

			MBca& iBca;

			TInt iCompletionError;

		};

	class CReader: public CExecutor

		{

		public:

			CReader(MBca& iBca);

			virtual ~CReader();

			void Read(TDes8& aPkt);

			virtual void DoCancel();

		};

	class CWriter: public CExecutor

		{

		public:

			CWriter(MBca& iBca);

			virtual ~CWriter();

			void Write(const TDesC8& aPkt);

			virtual void DoCancel();

		};

	/**

	Interface for BCA proxy 

	Test proxy inserts additional logic before dispatching the

	call to the actual BCA 

	@internalComponent

	*/

	class MBcaProxy

		{

		public:

			/** Releases all resources & memory associated with the BCA

			used in lieu of destructor */

			virtual void Release() = 0;

			/** 

			Requests BCA Open 

			@param aChannelId channelId */

			virtual void Open(const TDesC& aChannelId) = 0;

			/**

			Waits for BCA Open to complete. 

			@param aExpectedErr expected error code for Open 

			@leave if Open completes with error other than aExpectedErr 	*/

			virtual void WaitForOpenL(TInt aExpectedErr) = 0;

			/**

			Requests immediate BCA Close */

			virtual void Close() = 0;

			/** Requests graceful BCA shutdown */

			virtual void Shutdown() = 0;

			/**

			Waits for BCA Close to complete: returns once Shutdown completed.

			@param aExpectedErr expected error code for Shutdown 

			@leave if Shutdown completes with error other than aExpectedErr */

			virtual void WaitForShutdownL(TInt aExpectedErr) = 0;

			/**

			Requests BCA Read

			@param aBuf buffer to read into 	*/

			virtual void Read( TDes8& aBuf) = 0;

			/**

			Waits for BCA Read to complete: returns once Read completed. 

			@param aExpectedErr expected error code for Open 

			@leave if Read completes with error other than aExpectedErr 	*/

			virtual void WaitForReadL(TInt aExpectedErr) = 0;

			/**

			Requests BCA Write

			@param aBuf the buffer to write. */

			virtual void Write(const TDesC8& aBuf) = 0;

			/**

			Waits for BCA Write to complete: returns once Write completed. 

			@param aExpectedErr expected error code for Write 

			@leave if Write completes with error other than aExpectedErr

			*/

			virtual void WaitForWriteL(TInt aExpectedErr) = 0;

			/**

			Cancel BCA Read */

			virtual void CancelRead() = 0;

			/**

			Cancel BCA Write */

			virtual void CancelWrite() = 0;

			/**

			Request BCA Ioctl 

			@param aOptLevel option level

			@param aOptName option name

			@param aOpt packaged buffer with option value	*/

			virtual void Ioctl(TInt aOptLevel, TInt aOptName, TDes8& aOpt) = 0;

			/**

			Waits for BCA Ioctl to complete: returns once Ioctl completed. 

			@param aExpectedErr expected error code for Ioctl 

			@leave if Ioctl completes with error other than aExpectedErr

			*/

			virtual void WaitForIoctlL(TInt aExpectedErr) = 0;

			/** Cancels outstanding Ioctl */

			virtual void CancelIoctl() = 0 ;

		};

	/**

	BCA Test proxy:

	Routes requests to the BCA, performing test error checking

	Encapsulates common functionality for all BCA proxies */

	class CBcaTestProxy: public CBase, public MBcaProxy

		{

		public:

			CBcaTestProxy(CTestStep& aLogProvider, const TDesC& aProxyName);

		protected:

			CTestExecuteLogger& Logger();

			void VerifyErrCodeL(TInt aCodeToVerify, TInt aExpectedErrCode);

			void Release();

			void Open(const TDesC& aChannelId);

			void WaitForOpenL(TInt expectedErr);

			void Close();

			void Shutdown();

			void WaitForShutdownL(TInt aExpectedErr);

			void Read( TDes8& aBuf);

			void WaitForReadL(TInt expectedErr);

			void Write(const TDesC8& aBuf);

			void WaitForWriteL(TInt aExpectedErrCode);

			void CancelRead();

			void CancelWrite();

			void Ioctl( TInt aOptLevel, TInt aOptName, TDes8& aOpt);

			void WaitForIoctlL(TInt aExpectedErr);

			virtual void CancelIoctl();

			/**

			Test Step object owning the test logger */		

			CTestStep& iLogProvider;

			CReader* iReader;

			CWriter* iWriter;

			/** Status of request to Open */

			TRequestStatus iOpenRequest;

			/** Status of request to Close */

			TRequestStatus iShutdownRequest;

			/** Status of request to Read */

			//TRequestStatus iReadRequest;

			/** Status of request to Write */

			//TRequestStatus iWriteRequest;

			/** Status of request to Ioctl */

			TRequestStatus iIoctlRequest;

			/** Proxy name, for logging */

			TName iProxyName;

			/** BCA Dll owner */

			TDllAutoClose iBcaDll;

			/** The BCA */

			MBca* iBca;

		};	

	/** 

	xxBca Test Proxy

	Encapsulates xxBca specific functionality */	

	class CxxBcaProxy: 

		public CBcaTestProxy

		{

		public:

			static CxxBcaProxy* NewL(CTestStep& aLogger, const TDesC& aProxyName);

			void Release();

		protected:

			CxxBcaProxy(CTestStep& aLogger, const TDesC& aProxyName);

			void ConstructL();

		};

	} // namespace te_xxBcaUnitTests

#endif