// Copyright (c) 2007-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 testinterfacesettingbase.h

 // @internalComponent

 // 

 //

 #include "testinterfacesettingbase.h"

 #include "testinterfacebase.h"

 #include "controltransferrequests.h"

 namespace NUnitTesting_USBDI

 	{	

 CInterfaceSettingBase::CInterfaceSettingBase(const TDesC& aString)

 :	iHashEndpointFunction(EndpointNumberHash),

 	iIdRelEndpoint(EndpointIdentityRelationship),

 	iEndpoints(iHashEndpointFunction,iIdRelEndpoint)

 	{	

 	// Set the name of this interface setting

 	iSettingString.Copy(aString);

 	iInterfaceInfo().iString = &iSettingString;

 	// Zero count the number of endpoints used for this setting

 	iInterfaceInfo().iTotalEndpointsUsed = 0;

 	}

 CInterfaceSettingBase::~CInterfaceSettingBase()

 	{

 	LOG_FUNC

 	iEndpointReaders.ResetAndDestroy();

 	iEndpointWriters.ResetAndDestroy();

 	}

 const TDesC& CInterfaceSettingBase::Name() const

 	{

 	return iSettingString;

 	}

 void CInterfaceSettingBase::SetClassCodeL(TUint8 aClassCode,TUint8 aSubClassCode,TUint8 aDeviceProtocol)

 	{

 	// Set class specific information

 	iInterfaceInfo().iClass = TUsbcClassInfo(aClassCode,aSubClassCode,aDeviceProtocol);

 	}

 TInt CInterfaceSettingBase::AddEndpoint(TEndpoint& aEndpoint)

 	{

 	LOG_FUNC

 	if(aEndpoint.iEndpointNumber == EEndpoint0)

 		{

 		return KErrInUse;

 		}

 	if(iEndpoints.Count() < KMaxEndpointsPerClient)

 		{

 		// Set EEndpoint1, EEndpoint2, EEndpoint3, EEndpoint4 or EEndpoint5

 		iInterfaceInfo().iEndpointData[iEndpoints.Count()] = aEndpoint.iEndpointInfo;

 		iEndpoints.Insert(aEndpoint.iEndpointNumber,aEndpoint);

 		// Update the total endpoints used on this interface

 		iInterfaceInfo().iTotalEndpointsUsed = iEndpoints.Count();

 		return KErrNone;

 		}

 	else

 		{

 		return KErrOverflow;

 		}

 	}

 void CInterfaceSettingBase::CreateEndpointReaderL(RDevUsbcClient& aClientDriver,TUint aEndpoint)

 	{

 	LOG_FUNC	

 	// Create the reader for this endpoint and store in the container	

 	CEndpointReader* epReader = new (ELeave) CEndpointReader(aClientDriver,

 	iEndpoints.Find(static_cast<TEndpointNumber>(aEndpoint))->iEndpointNumber);

 	CleanupStack::PushL(epReader);

 	iEndpointReaders.AppendL(epReader);

 	CleanupStack::Pop(epReader);

 	}

 void CInterfaceSettingBase::CreateEndpointWriterL(RDevUsbcClient& aClientDriver,TUint aEndpoint)

 	{

 	LOG_FUNC	

 	// Create the writer for this endpoint and store in the container	

 	CEndpointWriter* epWriter = new (ELeave) CEndpointWriter(aClientDriver,

 	iEndpoints.Find(static_cast<TEndpointNumber>(aEndpoint))->iEndpointNumber);

 	CleanupStack::PushL(epWriter);

 	iEndpointWriters.AppendL(epWriter);

 	CleanupStack::Pop(epWriter);

 	}

 void CInterfaceSettingBase::WriteSpecifiedDataToEndpointL(const TDesC8& aData,TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access the correct writer for the given endpoint

 	// and write the data to the host			

 	iEndpointWriters[aEndpointNumber-1]->Write(aData, ETrue);

 	}

 void CInterfaceSettingBase::WriteSpecifiedDataToEndpointL(const TDesC8& aDataPattern, const TUint aNumBytes, TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access the correct writer for the given endpoint

 	// and write the data to the host

 	iEndpointWriters[aEndpointNumber-1]->WriteUsingPatternL(aDataPattern,aNumBytes,ETrue);

 	}

 void CInterfaceSettingBase::RepeatedWriteSpecifiedDataToEndpointL(const TDesC8& aDataPattern, TUint aNumBytesPerWrite, TUint aTotalNumBytes, TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access the correct writer for the given endpoint

 	// and write the data to the host

 	iEndpointWriters[aEndpointNumber-1]->WriteInPartsUsingPatternL(aDataPattern,aNumBytesPerWrite,aTotalNumBytes,ETrue);

 	}

 void CInterfaceSettingBase::WriteCachedEndpointDataToEndpointL(const TUint16 aReadEndpointNumber,TUint16 aWriteEndpointNumber)

 	{

 	LOG_FUNC

 	iEndpointWriters[aWriteEndpointNumber-1]->Write(iEndpointReaders[aReadEndpointNumber-1]->Buffer(), ETrue);

 	}

 void CInterfaceSettingBase::CancelWriteDataToEndpointL(TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access the correct writer for the given endpoint

 	// and cancel any outstanding write. This will not of course work for 'synchronous' writes.			

 	iEndpointWriters[aEndpointNumber-1]->Cancel();

 	}

 void CInterfaceSettingBase::WriteSynchronousSpecifiedDataToEndpointL(const TDesC8& aDataPattern, const TUint aNumBytes, TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access the correct writer for the given endpoint

 	// and write the data to the host

 	iEndpointWriters[aEndpointNumber-1]->WriteSynchronousUsingPatternL(aDataPattern,aNumBytes,ETrue);

 	}

 void CInterfaceSettingBase::WriteSynchronousSpecifiedDataToAndHaltEndpointL(const TDesC8& aDataPattern, const TUint aNumBytes, TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access the correct writer for the given endpoint

 	// and write the data to the host

 	iEndpointWriters[aEndpointNumber-1]->WriteSynchronousUsingPatternAndHaltL(aDataPattern,aNumBytes);

 	}

 void CInterfaceSettingBase::WriteSynchronousCachedEndpointDataToEndpointL(const TUint16 aReadEndpointNumber,TUint16 aWriteEndpointNumber)

 	{

 	LOG_FUNC

 	//Attempt to write the complete cached buffer by starting at zero and choosing the max length posible

 	WriteSynchronousCachedEndpointDataToEndpointL(aReadEndpointNumber, aWriteEndpointNumber, 0, KMaxTInt);

 	}

 void CInterfaceSettingBase::WriteSynchronousCachedEndpointDataToEndpointL(const TUint16 aReadEndpointNumber,TUint16 aWriteEndpointNumber, TUint aStartPoint, TUint aLength)

 	{

 	LOG_FUNC	

 	// Access the correct writer for the given endpoint

 	// Access the 'source' endpoint buffer. This contains data from that endpoint's last read.

 	// Write this data to the host using 'write' endpoint.

 	// Check data

 	TPtr8 dataPtr(iEndpointReaders[aReadEndpointNumber-1]->Buffer());

 	User::LeaveIfError(dataPtr.MaxLength() == 0);

 	if(aStartPoint+aLength>dataPtr.Length())

 		//allow use of excessive length to imply a write of all the rest of the buffer...

 		//..otherwise 'Mid' would panic!

 		{

 		aLength = dataPtr.Length() - aStartPoint;

 		}

 	// Do the 'Write'

 	// Note we need a synchronous 'Write' here

 	iEndpointWriters[aWriteEndpointNumber-1]->WriteSynchronous(iEndpointReaders[aReadEndpointNumber-1]->Buffer().Mid(aStartPoint, aLength), ETrue);

 	}

 TBool CInterfaceSettingBase::CachedEndpointResultL(const TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access endpoint buffer containing data from the endpoint's last read

 	// and validate with the supplied data pattern

 	return iEndpointReaders[aEndpointNumber-1]->IsValid();

 	}

 TInt CInterfaceSettingBase::NumBytesReadSoFarL(const TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access endpoint buffer containing data from the endpoint's last read

 	// and validate with the supplied data pattern

 	return iEndpointReaders[aEndpointNumber-1]->NumBytesReadSoFar();

 	}

 TInt CInterfaceSettingBase::NumBytesWrittenSoFarL(const TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access endpoint buffer containing data from the endpoint's last read

 	// and validate with the supplied data pattern

 	return iEndpointWriters[aEndpointNumber-1]->NumBytesWrittenSoFar();

 	}

 TBool CInterfaceSettingBase::ValidateCachedEndpointDataL(const TDesC8& aDataPattern, const TUint aNumBytes, const TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access endpoint buffer containing data from the endpoint's last read

 	// and validate with the supplied data pattern

 	return ValidateCachedEndpointDataL(aDataPattern, 0, aNumBytes, aEndpointNumber);

 	}

 TBool CInterfaceSettingBase::ValidateCachedEndpointDataL(const TDesC8& aDataPattern, const TUint aStartPoint, const TUint aNumBytes, const TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	__ASSERT_DEBUG(aDataPattern.Length()!=0, User::Panic(_L("Trying to validate with ZERO LENGTH STRING"), KErrArgument));

 	//Check data in endpoint buffer

 	TPtr8 dataToValidate(iEndpointReaders[aEndpointNumber-1]->Buffer());

 	User::LeaveIfError(dataToValidate.MaxLength() == 0);

 	TUint startPoint = aStartPoint%aDataPattern.Length();

 	TUint numStartBytes = (aDataPattern.Length() - startPoint)%aDataPattern.Length();

 	numStartBytes = aNumBytes<numStartBytes?aNumBytes:numStartBytes; //never test for more than aNumBytes

 	TUint fullRepeats = (aNumBytes-numStartBytes)/aDataPattern.Length();

 	TUint startEndPoint = (fullRepeats*aDataPattern.Length()) + numStartBytes;

 	TUint numEndBytes = aNumBytes - startEndPoint;//fullRepeats*aDataPattern.Length() - numStartBytes;

 	if(numStartBytes)

 		{

 		if(dataToValidate.Left(numStartBytes).Compare(aDataPattern.Mid(startPoint, numStartBytes)) != 0)

 			{

 			RDebug::Printf("ROUND TRIP VALIDATION: Start Bytes Match Failure");

 			RDebug::Printf("ROUND TRIP VALIDATION: numStartBytes = %d", numStartBytes);

 			RDebug::Printf("Start of sent data ...");

 			RDebug::RawPrint(aDataPattern.Mid(startPoint, numStartBytes));

 			RDebug::Printf("\n");

 			RDebug::Printf("ROUND TRIP VALIDATION: Start of returned data ...");				

 			RDebug::RawPrint(dataToValidate.Left(numStartBytes));

 			RDebug::Printf("\n");

 			return EFalse;

 			}

 		}

 	if(numEndBytes)

 		{

 		if(dataToValidate.Mid(startEndPoint,numEndBytes).Compare(aDataPattern.Left(numEndBytes)) != 0)

 			{

 			RDebug::Printf("ROUND TRIP VALIDATION: End Bytes Match Failure");

 			RDebug::Printf("ROUND TRIP VALIDATION: startEndPoint = %d, numEndBytes = %d", startEndPoint, numEndBytes);

 			RDebug::Printf("End of sent data ...");

 			RDebug::RawPrint(aDataPattern.Left(numEndBytes));

 			RDebug::Printf("\n");

 			RDebug::Printf("ROUND TRIP VALIDATION: End of returned data ...");				

 			RDebug::RawPrint(dataToValidate.Mid(startEndPoint,numEndBytes));

 			RDebug::Printf("\n");

 			return EFalse;

 			}

 		}

 	for(TInt i=0; i<fullRepeats; i++)

 		{

 		if(dataToValidate.Mid(numStartBytes + i*aDataPattern.Length(),aDataPattern.Length()).Compare(aDataPattern) != 0)

 			{

 			RDebug::Printf("ROUND TRIP VALIDATION: Repeated Bytes Match Failure, Repeat %d",i);

 			RDebug::Printf("sent data middle block ...");

 			RDebug::RawPrint(aDataPattern);

 			RDebug::Printf("\n");

 			RDebug::Printf("ROUND TRIP VALIDATION: Middle block of returned data ...");

 			RDebug::RawPrint(dataToValidate.Mid(numStartBytes + i*aDataPattern.Length(),aDataPattern.Length()));

 			RDebug::Printf("\n");

 			return EFalse; //from 'for' loop

 			}

 		}

 	return ETrue;

 	}

 void CInterfaceSettingBase::ReadDataFromEndpointL(TUint aNumBytes, TUint16 aEndpointNumber)	

 	{

 	LOG_FUNC	

 	// Access the correct readerer for the given endpoint

 	// and prepare to read the data to be sent by the host			

 	iEndpointReaders[aEndpointNumber-1]->ReadL(aNumBytes);

 	}

 void CInterfaceSettingBase::CancelAnyReadDataFromEndpointL(TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access the correct writer for the given endpoint

 	// and cancel any outstanding write. This will not of course work for 'synchronous' writes.			

 	iEndpointReaders[aEndpointNumber-1]->Cancel();

 	}

 void CInterfaceSettingBase::ReadDataFromAndHaltEndpointL(TUint aNumBytes, TUint16 aEndpointNumber)	

 	{

 	LOG_FUNC	

 	// Access the correct reader for the given endpoint

 	// and prepare to read the data to be sent by the host			

 	iEndpointReaders[aEndpointNumber-1]->ReadAndHaltL(aNumBytes);

 	}

 void CInterfaceSettingBase::RepeatedReadAndValidateFromEndpointL(const TDesC8& aDataPattern, TUint aNumBytesPerRead, TUint aTotalNumBytes, TUint16 aEndpointNumber)

 	{

 	LOG_FUNC	

 	// Access the correct reader for the given endpoint

 	// and prepare to read the data to be sent by the host

 	// using multiple 'Reads'

 	iEndpointReaders[aEndpointNumber-1]->RepeatedReadAndValidateL(aDataPattern, aNumBytesPerRead, aTotalNumBytes);

 	}

 void CInterfaceSettingBase::ReadDataUntilShortFromEndpointL(TUint aNumBytes, TUint16 aEndpointNumber)	

 	{

 	LOG_FUNC	

 	// Access the correct reader for the given endpoint

 	// and prepare to read the data to be sent by the host			

 	iEndpointReaders[aEndpointNumber-1]->ReadUntilShortL(aNumBytes);

 	}

 	}