#ifndef __BULK_BASE_TEST_CASE_H

 #define __BULK_BASE_TEST_CASE_H

 /*

 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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 BaseBulkTestCase.h

 * @internalComponent

 * 

 *

 */

 #include "BaseTestCase.h"

 #include "hosttransfers.h"

 #include "modelleddevices.h"

 #include "controltransferrequests.h"

 #include "TestCaseFactory.h"

 #include "FDFActor.h"

 #include <d32usbc.h>

 #include <d32usbdi.h>

 #include <e32debug.h>

 namespace NUnitTesting_USBDI

 	{

 const TUint  KPercent 				= 100;

 const TUint8 KMaxNumTimers 			= 4; //max number of timers used in any test

 const TUint8 KMaxNumOutTransfers	= 4; //max number of queued OUT transfers used in any Bulk  test

 const TUint8 KMaxNumInTransfers		= 4; //max number of queued IN transfers used in any Bulk  test

 class MBulkTestTimerObserver

 	{

 public:

 	virtual void HandleBulkTestTimerFired() = 0;

 	};

 class CBulkTestTimer : public CTimer

 	{

 public:

 	/**

 	2 phase construction

 	@param aTestDevice the test device object that will perform the remote wakeup event

 	*/

 	static CBulkTestTimer* NewL(MBulkTestTimerObserver& aParent);

 	/**

 	Destructor

 	*/

 	~CBulkTestTimer();

 private:

 	/**

 	*/

 	CBulkTestTimer(MBulkTestTimerObserver& aParent);

 	/**

 	*/

 	void ConstructL();

 private: // From CTimer

 	/**

 	*/

 	void RunL();

 private:

 	/**

 	The test device object to instruct to connect of disonnect

 	*/

 	MBulkTestTimerObserver& iParent;

 	};

 typedef TBuf<256> TMessageBuf;

 /**

 Base policy class for basic bulk test cases.  Test cases are active objects that execute their respective test cases

 and asynchronously complete when test case has finished

 */

 class CBaseBulkTestCase : public CBaseTestCase,

 						  public MUsbBusObserver,

 						  public MBulkTestTimerObserver

 	{

 public:

 	static CBaseBulkTestCase* NewL(TBool aHostRole);

 	~CBaseBulkTestCase(); 

 public: // From MUsbBusObserver

 	virtual void DeviceInsertedL(TUint aDeviceHandle);

 	virtual void DeviceRemovedL(TUint aDeviceHandle);

 	void BusErrorL(TInt aError);

 	void DeviceStateChangeL(RUsbDevice::TDeviceState aPreviousState,RUsbDevice::TDeviceState aNewState,

 			TInt aCompletionCode);

 	void HandleBulkTestTimerFired();

 protected:

 	enum TDeviceInsertedError

 		{

 		ENone,

 		EDeviceConfigurationError

 		};

 protected:

 /**

 	Constructor

 	@param aTestCaseId the identity that this test case is to represent

 	@param aHostFlag the flag for host role

 	*/

 	CBaseBulkTestCase(const TDesC& aTestCaseId,TBool aHostFlag, TBool aHostOnly = EFalse);

 	/**

 	Base class 2nd phase constructor

 	*/

 	void CBaseBulkTestCase::BaseBulkConstructL();

 	/**

 	Common implentations for most bulk transfer tests

 	*/

 	TInt BaseBulkDeviceInsertedL(TUint aDeviceHandle);

 	TInt BaseBulkDeviceInsertedL(TUint aDeviceHandle, TBool aUseTwoInterfaces);

 	TInt SetUpInterfaceAndPipesL(TUint aDeviceHandle, TUint8 aInterfaceNum);

 	void CloseInterfaceAndPipes();

 	void ExecuteHostTestCaseL();

 	void ExecuteDeviceTestCaseL();

 	void HostDoCancel();

 	void DeviceDoCancel();

 	void HostRunL();

 	void DeviceRunL();

 	TBool ValidateData (const TDesC8& aDataToValidate, const TDesC8& aDataPattern);

 	TBool ValidateData (const TDesC8& aDataToValidate, const TDesC8& aDataPattern, const TUint aNumBytes);

 	TBool ValidateData (const TDesC8& aDataToValidate, const TDesC8& aDataPattern, const TUint aStartPoint, const TUint aNumBytes);

 	void RecordTime(const TUint8 aTimerIndex);

 	TInt CheckTimes(const TUint8 aFirstTimerIndex, const TUint8 aSecondTimerIndex, const TUint aPercentage);

 	TInt CheckAndResetTimes(const TUint8 aFirstTimerIndex, const TUint8 aSecondTimerIndex, const TUint aPercentage);

 	void ResetTimes(const TUint8 aTimerIndex);

 protected:

 	CActorFDF* iActorFDF;

 	RUsbPipe iTestPipeInterface1BulkOut;

 	RUsbPipe iTestPipeInterface1BulkIn;

 	RUsbPipe iTestPipeInterface2BulkOut1;

 	RUsbPipe iTestPipeInterface2BulkOut2;

 	RUsbPipe iTestPipeInterface2BulkIn;

 	CEp0Transfer* iControlEp0;

 	RUsbInterface iUsbInterface0;

 	RUsbInterface iUsbInterface1;

 	RUsbInterface iUsbInterface2;

 	// Transfer objects

 	CBulkTransfer* iOutTransfer[KMaxNumOutTransfers];

 	CBulkTransfer* iInTransfer[KMaxNumInTransfers];

 	// Timer that may be used to fire mid bulk transfer EP0 requests at the client

 	CBulkTestTimer* iBulkTestTimer;

 	// The test device to be used for this test case

 	RUsbDeviceD* iTestDevice;

 	// Buffer for storing transfer IN data

 	HBufC8* iInBuffer;

 	// Ptr for 'iInBuffer'

 	TPtr8 iInBufferPtr;

 	// Buffer for storing transfer OUT data

 	HBufC8* iOutBuffer;

 	// Ptr for 'iOutBuffer'

 	TPtr8 iOutBufferPtr;

 	// Buffer for storing validation data

 	HBufC8* iValidateBuffer;

 	// Ptr for 'iValidateBuffer'

 	TPtr8 iValidateBufferPtr;

 	TInt iTransferResult;

 	TMessageBuf iMsg;

 	// TransferComplete Bit Mask

 	TUint	iTransferComplete;

 	// Set of timing facilities

 	TTime iStartTime[KMaxNumTimers];

 	TTime iEndTime[KMaxNumTimers];

 	TTimeIntervalMicroSeconds iTimeElapsed[KMaxNumTimers];

 	TInt iTimingError;

 	};

 	} //end namespace

 #endif