diff -r 000000000000 -r 96e5fb8b040d kerneltest/e32test/usbho/t_otgdi/inc/testcaseroot.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/usbho/t_otgdi/inc/testcaseroot.h Thu Dec 17 09:24:54 2009 +0200 @@ -0,0 +1,290 @@ +// 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: +// @internalComponent +// +// + +#ifndef TESTCASEROOT_H +#define TESTCASEROOT_H + +#include // OTGDI thunk headder (under test) +#include "debugmacros.h" +#include "testcasefactory.h" +#include "testpolicy.h" +#include "otgroot.h" // otg driver facade +#include "b2bwatchers.h" // otg watchers server + + +#define MINMAX_CLAMPVALUE(a,min,max) (a < min?a=min:(a>max?a=max:(int)0)) + +// keyboard input, different from KErrNone and KErrCancel +const TInt KTestCaseWatchdogTO = 1025; +const TInt KTestCaseFailureEventReceived = 1026; // Meaning that some specific undesired event occurred during a test step + +const TInt KB2BStepTimeoutDefaultMS = 5000; // 5 seconds +const TInt KB2BStepTimeoutShortMS = 1000; // timeout for things that should happen virtually immediately +const TInt KB2BStepRoleSustainB_MS = 30000; // B-device must stay in role for at least 30 seconds +const TInt KB2BStepRoleSustainA_MS = 35000; // A-device must stay in role longer before it drops the bus + + +// Prompts to the tester + // H4 width **************************** +_LIT(KAttachOETAsBDevice, "Attach OET, SW9 set as B-Device.\n"); +_LIT(KInsertAConnectorPrompt, "Please insert 'A'-connector now.\n"); +_LIT(KRemoveAConnectorPrompt, "Please remove 'A'-connector now.\n"); +_LIT(KInsertBCablePrompt, "Please insert 'B'-cable end now.\n "); +_LIT(KInsertACablePrompt, "Please insert 'A'-cable end now.\n "); +_LIT(KInsertAIntoPC, "Please insert 'A'-connector into PC\n "); +_LIT(KRemoveAFromPC, "Please remove 'A'-connector from PC\n "); +_LIT(KPressAnyKeyToStart, "Press any key to start..."); +_LIT(KPressAnyKeyToContinue, "Press any key to proceed..."); +_LIT(KPressAnyKeyToEnd, "Press any key to end."); +_LIT(KMsgErrorPreconditionFailed, "Test precondition not met!\n"); +_LIT(KMsgBPlugNotFound, "B plug not detected ERROR!\n"); +_LIT(KMsgAPlugNotFound, "A plug not detected ERROR!\n"); +_LIT(KMsgWaitingForSRPTimeout, "Waiting for SRP timeout (32 s)\n"); +_LIT(KMsgWaitingForSRPInitiated, "Waiting for SRP initiation\n"); + + +_LIT(KTestTypeB2BMsg, "== B2B connected test ==\n"); +_LIT(KRoleMasterMsg, "== MASTER ==\n"); +_LIT(KRoleSlaveMsg, "== SLAVE ==\n"); + +// CActive helper string +_LIT(KMsgAlreadyActive, "Is already Active"); + +// name of the OTGDI ldd +_LIT(KOTGDeviceInterfaceDriverName,"otgdi"); + +// names for the USBC ldd +_LIT(KUsbcLddFileName, "eusbc"); +_LIT(KUsbDeviceName, "Usbc"); + + +const TInt KDelayDurationForUserActivityMS = 15000; +const TInt KDelayDurationForQEmpty = 200; // > 17 ms +const TInt KDelayDurationForLocalTrigger = 50; // 50 ms (API call with a local side-effect) + +const TInt KDelayBeforeBusDropUs = 50000; // 50ms time after VBus rise before we may drop it - prevents + // ambiguous Vbus pulse signalling. + +const TInt KTestProductID = 0x2670; // Symbian USB PID product-id + +// Specification values +const TInt KSpec_TA_SRP_RSPNS = 4900; // ms [OTG section 5.3.2] - NOTE: A device timeout=32 seconds + + +const TInt KOperationRetriesMax = 3; // # retries on various operations. +const TInt KParameterTextLenMax = 80; // command-line param length + +// map the number of times to re-run the OPEN/CLOSE tests to the command-line parameter +// this parameter is also used for many other tests that allow itteration count control +#define OPEN_REPEATS gOpenIterations +#define OPEN_MINREPEATS 1 +#define OPEN_MAXREPEATS 1000 + +// # times to repeat the steps +#define OOMOPEN_REPEATS gOOMIterations +#define OOM_MINREPEATS 1 +#define OOM_MAXREPEATS 99 + +// panics +enum + { + EPanicAlreadyActive=1000, + EPanicPropertyDeleted = 1001, + EPanicWatchdogError = 1002 + }; + + + +/** Abstract base class to derive all tests from +*/ +class CTestCaseRoot : public CActive, public COtgRoot + { +public: + virtual ~CTestCaseRoot(); + + /** Provides us with a pointer to the test policy which instantiated this object + in OTGDI, the policy does not do any policy making, it merely instantiates the test + and provides parameters */ + void SetTestPolicy(CBasicTestPolicy* aTestPolicy); + + void DisplayTestCaseOptions(); + + virtual void DescribePreconditions() = 0; + virtual TInt GetStepIndex() = 0; + + // Performs the test case + void PerformTestL(); + + virtual void ExecuteTestCaseL()=0; // override to implement + + // Provides to the caller the identity of this test case + // @return descriptor referrence to the test case identity + TDesC& TestCaseId(); + + // Retrieve the test result for the executed test case + // @return the test case result + TInt TestResult() const; + + TBool IsActiveOutstanding() {return(IsActive());}; + + +protected: + /** + Constructor + @param aTestCaseId the identity that this test case is to represent + @param aHostFlag the flag for host role + */ + CTestCaseRoot(const TDesC& aTestCaseId, TBool aHost); + + /** + Base class 2nd phase constructor + */ + void BaseConstructL(); + + /** + Called when Cancel is called (if active) + */ + virtual void DoCancel(); + + /** + Called when the this AO has been scheduled + */ + virtual void RunL(); + + /** + This default implementation just informs the test controller that this specific test case RunL + left with the error code so that the active scheduler will not Panic. This indicates that the test case failed. + Derived test cases are expected to override for exact knowledge of error + @param aError the error from a derived test case execution + @return KErrNone + */ + virtual TInt RunError(TInt aError); + + /** + State that the test case has failed with the given error code + @param aFailResult the failure result for the test case + */ + void TestFailed(TInt aFailResult, const TDesC &aErrorDescription); + void TestFailed2(TInt aFailResult, const TDesC &aErrorDescription, TInt errorCode); + + void AssertionFailed(TInt aFailResult, const TDesC &aErrorDescription) {TestFailed(aFailResult, aErrorDescription);}; + void AssertionFailed2(TInt aFailResult, const TDesC &aErrorDescription, TInt errorCode) {TestFailed2(aFailResult, aErrorDescription, errorCode);}; + + virtual void PrintStepName(const TDesC &aStepName); + + /** + Instruct the test case that it has passed + */ + void TestPassed(); + + void SelfComplete(TInt aError=KErrNone); + + CBasicTestPolicy& TestPolicy(); + + // override this method in each test that needs KB input + virtual void ProcessKey(TKeyCode &aKey); + + void ProcessEngineKey(TKeyCode &aKey); + + // Issue request + void RequestCharacter(); + + virtual void RunStepL() =0; + virtual void PreRunStep(); + virtual void PostRunStep(); + + + + // DATA MEMBERS +protected: + /** bypass some manual steps, will skip preconditioning steps + when you want to run the tests in the correct sequence (IE previous test leaves + the external inputs in a state ready for this test). + */ + TBool iAutomated; + + + /** + The timer resource for timeout of test actions + and possibly other uses + */ + RTimer iTimer; + + /** + The execution result for the test case + */ + TInt iTestResult; + + + // key input status to wait upon (wrap it in a method-call) + TKeyCode iKeyCodeInput; + + CConsoleBase* iConsole; // A console for reading from + TBool iDualRoleCase; // True for tests with 2 roles (Master/Slave) + +private: + TBool iRequestedChar; + + TTime iStartTime; // time that the test started at + + TBuf iRootID; // test case name or step name + + /** + */ + CBasicTestPolicy* iTestPolicy; + + /** + The identity of the test case + */ + TBuf iTestCaseId; + + }; // CTestCaseRoot + + +/* *************************************************************************** + * Abstract class for B2b test-cases adds B2B helpers and datas to the + * CTestCaseRoot class. + */ +class CTestCaseB2BRoot : public CTestCaseRoot + { +public: + static CTestCaseB2BRoot* NewL(const TDesC& aTestCaseId, TBool aHost, TRequestStatus &aStatus); + virtual ~CTestCaseB2BRoot(); + + virtual void DescribePreconditions(); + void CheckRoleConnections(); + + virtual void StepB2BPreconditions(); + + +protected: + CTestCaseB2BRoot(const TDesC& aTestCaseId, TBool aHost, TRequestStatus &aStatus); + void ConstructL(); + + void PrintStepName(const TDesC &aStepName); + // the default B2B action is to clear the expected notification Q at the start of step, + // and the received q as the step ends + void PreRunStep(); // from CTestCaseRoot + void PostRunStep(); // from CTestCaseRoot + +protected: + CNotifyCollector iCollector; + + }; + + +#endif // TESTCASEROOT_H