diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kerneltest/e32test/usbho/t_usbdi/src/PBASE-T_USBDI-0493.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/kernelhwsrv/kerneltest/e32test/usbho/t_usbdi/src/PBASE-T_USBDI-0493.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,338 @@ +// 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 PBASE-T_USBDI-0493.cpp +// @internalComponent +// +// + +#include "PBASE-T_USBDI-0493.h" +#include "testpolicy.h" +#include "modelleddevices.h" +#include "testliterals.h" + + + + +namespace NUnitTesting_USBDI + { +const TInt KLiteralEnglish8Length = KLiteralEnglish8().Length(); +const TUint KBulkTransferMaxSize = 320; +const TUint KHostNumWriteBytes = 256; +const TUint KHostNumReadBytes = 256; +const TUint KHostFinalNumReadBytes = 300; + +const TUint KStartNumTransferBytes = 1023; +const TUint KFinishNumTransferBytes = 1025; + +const TUint KClientNumReadBytes = 2000; + +//Make these single bit values ... +// ... so that their completion can be easily recorded in a bit mask! +const TInt KBulkTransferInId0 = 1<<0; +const TInt KBulkTransferInId1 = 1<<1; +const TInt KBulkTransferInId2 = 1<<2; +const TInt KBulkTransferInId3 = 1<<3; +const TInt KBulkTransferOutId0 = 1<<4; +const TInt KBulkTransferOutId1 = 1<<5; +const TInt KBulkTransferOutId2 = 1<<6; +const TInt KBulkTransferOutId3 = 1<<7; + +const TInt KUnexpectedTransferID = -101; +const TInt KUndefinedStep = -102; + + +_LIT(KTestCaseId,"PBASE-T_USBDI-0493"); +const TFunctorTestCase CUT_PBASE_T_USBDI_0493::iFunctor(KTestCaseId); + +CUT_PBASE_T_USBDI_0493* CUT_PBASE_T_USBDI_0493::NewL(TBool aHostRole) + { + CUT_PBASE_T_USBDI_0493* self = new (ELeave) CUT_PBASE_T_USBDI_0493(aHostRole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + + +CUT_PBASE_T_USBDI_0493::CUT_PBASE_T_USBDI_0493(TBool aHostRole) +: CBaseBulkTestCase(KTestCaseId,aHostRole), + iNumTransferBytes(KStartNumTransferBytes), + iCaseStep(EInProgress) + { + } + + +void CUT_PBASE_T_USBDI_0493::ConstructL() + { + BaseBulkConstructL(); + } + + +CUT_PBASE_T_USBDI_0493::~CUT_PBASE_T_USBDI_0493() + { + LOG_FUNC + } + +void CUT_PBASE_T_USBDI_0493::Ep0TransferCompleteL(TInt aCompletionCode) + { + LOG_FUNC + + RDebug::Printf("Ep0TransferCompleteL with aCompletionCode = %d",aCompletionCode); + + if(aCompletionCode != KErrNone) + { + if(iCaseStep == EFailed) + {// todo, cope with errors + } + else + { + TBuf<256> msg; + msg.Format(_L(" Transfer to control endpoint 0 was not successful"),aCompletionCode); + RDebug::Print(msg); + iCaseStep = EFailed; + TTestCaseFailed request(aCompletionCode,msg); + iControlEp0->SendRequest(request,this); + return; + } + } + + switch(iCaseStep) + { + // Test case passed + case EPassed: + TestPassed(); + break; + + // Test case failed + case EFailed: + TestFailed(KErrCompletion); + break; + + case ETransferOut: + RDebug::Printf("Try to send %d bytes of data", iNumTransferBytes); + RDebug::RawPrint(KLiteralEnglish8().Mid(0*KHostNumWriteBytes, KHostNumWriteBytes)); + iOutTransfer[0]->TransferOut(KLiteralEnglish8().Mid(0*KHostNumWriteBytes, KHostNumWriteBytes), EFalse); + iOutTransfer[1]->TransferOut(KLiteralEnglish8().Mid(1*KHostNumWriteBytes, KHostNumWriteBytes), EFalse); + iOutTransfer[2]->TransferOut(KLiteralEnglish8().Mid(2*KHostNumWriteBytes, KHostNumWriteBytes), EFalse); + iOutTransfer[3]->TransferOut(KLiteralEnglish8().Mid(3*KHostNumWriteBytes, iNumTransferBytes - 3*KHostNumWriteBytes), ETrue); + break; + + case ETransferIn: + RDebug::Printf("Try to receive max %d bytes of data", 3*KHostNumReadBytes + KHostFinalNumReadBytes); + iInTransfer[0]->TransferIn(KHostNumReadBytes); + iInTransfer[1]->TransferIn(KHostNumReadBytes); + iInTransfer[2]->TransferIn(KHostNumReadBytes); + iInTransfer[3]->TransferIn(KHostFinalNumReadBytes); + break; + + default: + RDebug::Printf(" Unknown test step"); + TestFailed(KErrUnknown); + break; + } + } + +void CUT_PBASE_T_USBDI_0493::TransferCompleteL(TInt aTransferId,TInt aCompletionCode) + { + LOG_FUNC + Cancel(); + + TInt err(KErrNone); + TBuf<256> msg; + RDebug::Printf("Transfer completed (id=%d), aCompletionCode = %d",aTransferId, aCompletionCode); + + switch(iCaseStep) + { + case ETransferOut: + if(aCompletionCode != KErrNone) + { + err = KErrCorrupt; + msg.Format(_L(" No data sent on bulk OUT request"),aCompletionCode); + break; //switch(iCaseStep) + } + + switch(aTransferId) + { + case KBulkTransferOutId0: + case KBulkTransferOutId1: + case KBulkTransferOutId2: + case KBulkTransferOutId3: + iTransferComplete |= aTransferId; + RDebug::Printf("Transfer %d completed", aTransferId); + break; //switch(aTransferId) + + default: + iTransferComplete = 0; //reset + err = KUnexpectedTransferID; + msg.Format(_L(" Unexpected transfer ID, wanted %d or %d or %d or %d, got %d"), + err, KBulkTransferOutId0, KBulkTransferOutId1, KBulkTransferOutId2, KBulkTransferOutId3, aTransferId); + break; //switch(aTransferId) + } + + if(err==KErrNone && iTransferComplete == (KBulkTransferOutId0 | KBulkTransferOutId1 | KBulkTransferOutId2 | KBulkTransferOutId3)) + { + RDebug::Printf("Try to receive back sent data. Transfers Completed %d", iTransferComplete); + iCaseStep = ETransferIn; + TWriteSynchronousCachedReadDataRequest request(1,1,1); //Use first read EP and first write EP (on interface 1) + iControlEp0->SendRequest(request,this); + iTransferComplete = 0; //reset + } + break; //switch(iCaseStep) + + case ETransferIn: + if(aCompletionCode != KErrNone) + { + err = KErrCorrupt; + msg.Format(_L(" No data sent on bulk IN request"),aCompletionCode); + break; //switch(iCaseStep) + } + switch(aTransferId) + { + case KBulkTransferInId0: + case KBulkTransferInId1: + case KBulkTransferInId2: + case KBulkTransferInId3: + iTransferComplete |= aTransferId; + break; //switch(aTransferId) + + default: + RDebug::Printf("Bad Transfer ID"); + iTransferComplete = 0; //reset + err = KUnexpectedTransferID; + msg.Format(_L(" Unexpected transfer ID, wanted %d or %d or %d or %d, got %d"), + err, KBulkTransferInId0, KBulkTransferInId1, KBulkTransferInId2, KBulkTransferInId3, aTransferId); + break; //switch(aTransferId) + } + + if(err==KErrNone && iTransferComplete == (KBulkTransferInId0 | KBulkTransferInId1 | KBulkTransferInId2 | KBulkTransferInId3)) + { + // compare data rcvd now + TPtrC8 data1(iInTransfer[0]->DataPolled()); + TPtrC8 data2(iInTransfer[1]->DataPolled()); + TPtrC8 data3(iInTransfer[2]->DataPolled()); + TPtrC8 data4(iInTransfer[3]->DataPolled()); + if(ValidateData(data1, KLiteralEnglish8().Mid(0*KHostNumReadBytes, KHostNumReadBytes)) == EFalse) + { + err = KErrCompletion; //indicates data validation failure + break; //switch(iCaseStep) + } + + if(ValidateData(data2, KLiteralEnglish8().Mid(1*KHostNumReadBytes, KHostNumReadBytes)) == EFalse) + { + err = KErrCompletion; //indicates data validation failure + break; //switch(iCaseStep) + } + + if(ValidateData(data3, KLiteralEnglish8().Mid(2*KHostNumReadBytes, KHostNumReadBytes)) == EFalse) + { + err = KErrCompletion; //indicates data validation failure + break; //switch(iCaseStep) + } + + if(ValidateData(data4, KLiteralEnglish8().Mid(3*KHostNumReadBytes, iNumTransferBytes - 3*KHostNumReadBytes)) == EFalse) + { + err = KErrCompletion; //indicates data validation failure + break; //switch(iCaseStep) + } + + if(err == KErrNone) + { + // Comparison is a match + RDebug::Printf("Comparison for IN transfer is a match - Number of Transfer Bytes %d", iNumTransferBytes); + iTransferComplete = 0; //reset + if(++iNumTransferBytes<=KFinishNumTransferBytes) + /* + Loop round again having added one to + the number of transfer bytes to be used. + In this test there should be three repeats of the underlying + "Transfer Out followed by Transfer In" test. + The repeats will use + KStartNumTransferBytes, + KStartNumTransferBytes+1, + and finally + KFinishNumTransferBytes. + */ + { + iCaseStep = ETransferOut; + TEndpointReadUntilShortRequest request(1,1,KClientNumReadBytes);// EP1 because 1st reader EP + iControlEp0->SendRequest(request,this); + break; //switch(iCaseStep) + } + iCaseStep = EPassed; + TTestCasePassed request; + iControlEp0->SendRequest(request,this); + } + } + break; //switch(iCaseStep) + + default: + err = KUndefinedStep; + msg.Format(_L(" Undefined case step %d reached"),KUndefinedStep, iCaseStep); + break; //switch(iCaseStep) + } + + if(err!=KErrNone) + { + RDebug::Print(msg); + iCaseStep = EFailed; + TTestCaseFailed request(err,msg); + iControlEp0->SendRequest(request,this); + return; + } + } + + +void CUT_PBASE_T_USBDI_0493::DeviceInsertedL(TUint aDeviceHandle) + { + LOG_FUNC + Cancel(); + RDebug::Printf("****** Father William Pattern Length is %d bytes! *********", KLiteralEnglish8Length); + if(BaseBulkDeviceInsertedL(aDeviceHandle) == EDeviceConfigurationError) + // Prepare for response from control transfer to client + { + iCaseStep = EFailed; + } + + // Create the bulk transfers + RDebug::Printf("Trying to create the bulk transfers - size 0x%u", KBulkTransferMaxSize); + iInTransfer[0] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkIn,iUsbInterface1,KBulkTransferMaxSize,*this,KBulkTransferInId0); + iInTransfer[1] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkIn,iUsbInterface1,KBulkTransferMaxSize,*this,KBulkTransferInId1); + iInTransfer[2] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkIn,iUsbInterface1,KBulkTransferMaxSize,*this,KBulkTransferInId2); + iInTransfer[3] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkIn,iUsbInterface1,KBulkTransferMaxSize,*this,KBulkTransferInId3); + iOutTransfer[0] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkOut,iUsbInterface1,KBulkTransferMaxSize,*this,KBulkTransferOutId0); + iOutTransfer[1] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkOut,iUsbInterface1,KBulkTransferMaxSize,*this,KBulkTransferOutId1); + iOutTransfer[2] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkOut,iUsbInterface1,KBulkTransferMaxSize,*this,KBulkTransferOutId2); + iOutTransfer[3] = new (ELeave) CBulkTransfer(iTestPipeInterface1BulkOut,iUsbInterface1,KBulkTransferMaxSize,*this,KBulkTransferOutId3); + + // Initialise the descriptors for transfer + RDebug::Printf("Initialising the transfer descriptors"); + TInt err = iUsbInterface1.InitialiseTransferDescriptors(); + if(err != KErrNone) + { + TBuf<256> msg; + msg.Format(_L(" Unable to initialise transfer descriptors"),err); + RDebug::Print(msg); + iCaseStep = EFailed; + TTestCaseFailed request(err,msg); + iControlEp0->SendRequest(request,this); + return; + } + + RDebug::Printf("Ask client to read %d bytes of data", KClientNumReadBytes); + iCaseStep = ETransferOut; + TEndpointReadUntilShortRequest request(1,1,KClientNumReadBytes);// EP1 because 1st reader EP + iControlEp0->SendRequest(request,this); + } + + } //end namespace