diff -r 7fdc9a71d314 -r 8ad140f3dd41 stif/TestCombiner/inc/TestCombiner.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stif/TestCombiner/inc/TestCombiner.h Wed Oct 13 16:17:58 2010 +0300 @@ -0,0 +1,883 @@ +/* +* Copyright (c) 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: This file contains the header file of the +* TestCombiner module of STIF Test Framework. +* +*/ + +#ifndef TESTCOMBINER_H +#define TESTCOMBINER_H + +// INCLUDES +#include + +#include +#include +#include +#include +#include +#include "TestKeywords.h" +#include "TestCombinerEvent.h" +#include "TestCombinerUtils.h" +#include "STIFMeasurement.h" + +// CONSTANTS +// Printing priorities +const TInt KPrintPriExec = 400; +const TInt KPrintPriLow = 300; +const TInt KPrintPriNorm = 200; +const TInt KPrintPriHigh = 100; +// Log dir and file +_LIT( KTestCombinerLogDir, "\\Logs\\TestFramework\\TestCombiner\\" ); +_LIT( KTestCombinerLogFile, "TestCombiner.txt" ); +_LIT( KTestCombinerLogFileWithTitle, "TestCombiner_[%S].txt" ); +// Configuration file tags +_LIT( KTestStartTag, "[Test]" ); +_LIT( KTestEndTag, "[Endtest]" ); +// Define tags +_LIT( KDefineStartTag, "[Define]" ); +_LIT( KDefineEndTag, "[Enddefine]" ); +// Initialization tags +_LIT( KInitStartTag, "[Init]" ); +_LIT( KInitEndTag, "[Endinit]" ); +_LIT( KInitRcpTimeout, "rcptimeout" ); + +// Remote protocol timeout +const TInt KRemoteProtocolTimeout = 30000000; +// Remote protocol Master id +const TUint32 KRemoteProtocolMasterId = 0xdeadbeef; + +// Loop counter macro +_LIT( KLoopCounter, "LOOP_COUNTER" ); + +// MACROS +// None + +// DATA TYPES +// None + +// FUNCTION PROTOTYPES +// None + +// FORWARD DECLARATIONS +class CTestRunner; +class CTestCase; +class CTCTestCase; +class CRemoteTestCase; +class CTCTestModule; +class CRemoteTimer; +class CRemoteReceiver; +class CRemoteSendReceive; +class TTestMeasurement; + +// CLASS DECLARATION + +// DESCRIPTION +// CTestCombiner contains the Test Module interface of TestCombiner +// for STIF Test Framework + +NONSHARABLE_CLASS(CTestCombiner) + :public CTestModuleBase + { + public: // Enumerations + + private: // Enumerations + + public: // Constructors and destructor + /** + * Two-phased constructor. + */ + static CTestCombiner* NewL(); + + /** + * Destructor. + */ + ~CTestCombiner(); + + public: // New functions + /** + * Test Case completion from CTCTestCase. + */ + void Complete( CTestCase* aTestCase, TInt aError=KErrNone ); + + /** + * Set event request pending. + */ + void SetEventPendingL( TEventIf aEvent ); + + /** + * Handles timeouts. + */ + void RemoteTimeout(); + + /** + * Handles responce received from slave + */ + void ReceiveResponse( TDesC& aMsg ); + + public: // Functions from base classes + /** + * Test module initialization. + */ + TInt InitL( TFileName& aIniFile, TBool aFirstTime ); + + /** + * GetTestCasesL is used to inquire testcases. + */ + TInt GetTestCasesL( const TFileName& aConfigFile, + RPointerArray& aTestCases ); + /** + * RunTestCase is used to run an individual test case specified + * by aTestCase. + */ + TInt RunTestCaseL( const TInt aCaseNumber, + const TFileName& aConfig, + TTestResult& aResult ); + + protected: // New functions + + protected: // Functions from base classes + + private: + /** + * C++ default constructor. + */ + CTestCombiner(); + + /** + * By default Symbian OS constructor is private. + */ + void ConstructL(); + + /** + * GetTestCaseL gets the specified test case section + * from the configfile. + */ + CStifSectionParser* GetTestCaseL( TInt aCaseNumber, + const TFileName& aConfig ); + + /** + * RunTestL runs the testcase specified in section. + */ + void RunTestL(); + + /** + * StartTestL starts a specified testcase from another test module. + */ + TInt StartTestL( CStartInfo& aStartInfo ); + + /** + * GetTestModuleL returns a specified test module description. + */ + CTCTestModule* GetTestModuleL( TDesC& aModule, + TDesC& aIniFile, + const TDesC& aConfigFile ); + + /** + * Gets a testcase identified with testid from test case array. + */ + CTestCase* GetTest( TDesC& aTestId ); + + /** + * Gets a running testcase identified with testid from test case array. + */ + CTestCase* GetRunningTest( TDesC& aTestId ); + + /** + * Gets a testcase identified with testid from test case array. + */ + CTCTestCase* GetLocalTest( TDesC& aTestId ); + + /** + * Gets a running testcase identified with testid from test case array. + */ + CTCTestCase* GetLocalRunningTest( TDesC& aTestId ); + + /** + * Gets a testcase identified with aSlaveId from slave array. + */ + CRemoteTestCase* GetRemoteTest( TDesC& aTestId ); + + /** + * Gets a testcase identified with aSlaveId from slave array. + */ + CRemoteTestCase* GetRemoteTest( TUint32 aSlaveId ); + + CRemoteTestCase* GetRemoteTestRunSent( TUint32 aSlaveId ); + /** + * Gets a running testcase identified with aSlaveId from slave array. + */ + CRemoteTestCase* GetRunningRemoteTest( TUint32 aSlaveId ); + + /** + * Gets a testcase running on slave with aSlaveDevId. + */ + CRemoteTestCase* GetRemoteRunningTestOnSlave( TUint32 aSlaveDevId ); + + /** + * Gets a correct CRemoteSendReceive object on slave with aSlaveId. + */ + CRemoteSendReceive* GetRemoteSendReceive( TUint32 aSlaveId ); + + /** + * Get running slave. + */ + CSlaveInfo* CTestCombiner::GetSlave( TUint32 aSlaveId ); + CSlaveInfo* CTestCombiner::GetSlave( TDesC& aSlaveName ); + + /** + * Check requested events and send unset to first requested. + */ + TBool UnsetEvent( TEventIf& aEvent, TRequestStatus& aStatus ); + + /** + * Read initialization from file. + */ + void ReadInitializationL( const TDesC& aIniFile ); + + /** + * Executes measurement script line. + */ + void ExecuteMeasurementL( CStifItemParser* aItem ); + + /** + * Starts measurement. + */ + void StartMeasurementL( const TDesC& aType, CStifItemParser* aItem ); + + /** + * Stops measurementplugin's measurement. + */ + void StopMeasurementL( const TDesC& aType ); + + /** + * Returns new index for test module controller. + * This number is appended to module controller name. + * This method is used when option to run every test case in separate + * process is set to on. + */ + TInt GetIndexForNewTestModuleController(void); + + /** + * Append to TC's result description (if possible due to length) + * limitation provided text in [] brackets. + */ + void AppendTestResultToResultDes(TDes& aResultDescr, const TDesC& aTestCaseResultDescr); + + + public: // Data + // Logger + CStifLogger* iLog; + + protected: // Data + + private: // Data + // Test case array of running/runned test cases + RPointerArray iTestCases; + + // SendReceive array(asynchronous sendreveive) + RPointerArray iSendReceive; + + // Array of test modules + RPointerArray iTestModules; + + // TestId of the waited (by complete keyword) test case + TName iWaitTestCase; + + // Flag to indicate that activescheduler is started + TBool iSchedulerActive; + + // Number of currently running test cases + TInt iRunningTests; + + // Test case result of the TestCombiner + TInt iResult; + + // Error code in case when execution of script fails + TInt iScriptFailed; + + // Error description in case when execution of script fails + TName iScriptFailedDescription; + + // Sectionparser for the current testcase + CStifSectionParser* iSectionParser; + + // Pointer to used testrunner + CTestRunner* iTestRunner; + + // Pointer to used testrunner + CRemoteReceiver* iRemoteReceiver; + + // Event for async NotifyEvent + TEventIf iEvent; + TEventIfPckg iEventPckg; + + RPointerArray iEventArray; + + // Predefined values are listed here + RPointerArray iDefined; + + // CSlaveInfo + RPointerArray iSlaveArray; + + // Remote protocol timeout + TInt iRemoteTimeout; + + // Variable for abortimmediately keyword @js + TBool iCancelIfError; + + // Number of the failed test case, needed when using + // abortimmediately keyword @js + TInt iFailedTestCase; + + // CStifTestMeasurement object + RPointerArray iTestMeasurementArray; + + // Indicate that loop is used in test case file. + // This is used for reseting and allowing allocated id's etc. + // (E.g. testid values can be same in loop). + TBool iLoopIsUsed; + RArray iLoopAllocationArray; + + // Standard Logger + CStifLogger* iStdLog; + + // Test case Logger + CStifLogger* iTCLog; + + // Flag which says if test case title should be appended to the + // log file name. This is read from SettingServer + TBool iAddTestCaseTitleToLogName; + + // Counter for created TCModuleControllers + TInt iIndexTestModuleControllers; + + // Is this UI testing? + // If yes, then Test Engine works in a specific way. + // It creates new process for every test scripter's test case + // and deletes it after test case has finished. + TBool iUITestingSupport; + + // Should every test case be executed in separate process? + // This option is similar to iUITestingSupport, however + // it does not delete the process after test case is finished. + TBool iSeparateProcesses; + + public: // Friend classes + + protected: // Friend classes + + private: // Friend classes + friend class CTestRunner; + friend class CTestEventNotifier; + + }; + +// CLASS DECLARATION + +// DESCRIPTION +// CTestRunner parses the TestCombiner configuration file and +// runs a testcase. CTestRunner is the friend of CTestCombiner +// and uses its private member variables directly. + +NONSHARABLE_CLASS(CTestRunner) + :public CActive + { + public: // Enumerations + + private: // Enumerations + enum TRunnerState{ + ERunnerIdle, + ERunnerRunning, + ERunnerWaitTestCase, + ERunnerWaitEvent, + ERunnerWaitUnset, + ERunnerWaitTimeout, + ERunnerCancel, + ERunnerError, + ERunnerAllocate, + ERunnerFree, + ERunnerRemote, + ERunnerReady, + }; + + public: // Constructors and destructor + /** + * Two-phased constructor. + */ + static CTestRunner* NewL( CTestCombiner* aTestCombiner ); + + /** + * Destructor. + */ + ~CTestRunner(); + + public: // New functions + /** + * Calls SetActive() from CActive. + */ + void SetRunnerActive(); + + /** + * Handles received response from slave. + */ + TBool ReceiveResponseL( TDesC& aMsg ); + + /** + * Cancel testcases. + */ + void CancelTestCases(); + + public: // Functions from base classes + /** + * RunL derived from CActive handles the completed requests. + */ + void RunL(); + + /** + * DoCancel derived from CActive handles the Cancel. + */ + void DoCancel(); + + /** + * RunError derived from CActive handles errors from active handler. + */ + TInt RunError( TInt aError ); + + protected: // New functions + + protected: // Functions from base classes + + private: + /** + * C++ default constructor. + */ + CTestRunner( CTestCombiner* aTestCombiner ); + + /** + * By default Symbian OS constructor is private. + */ + void ConstructL(); + + /** + * Executes one script line. + */ + TBool ExecuteLineL( CStifItemParser* aItem ); + + /** + * Executes run script line. + */ + TBool ExecuteRunL( CStifItemParser* aItem ); + + /** + * Parses run parameters. + */ + void ParseRunParamsL( CStifItemParser* aItem, CStartInfo& aStartInfo ); + + /** + * Executes test control script line. + */ + TBool ExecuteTestCtlL( CStifItemParser* aItem, + TTCKeywords::TKeywords aKeyword ); + + /** + * Executes pause in combiner + */ + TBool ExecuteCombinerPauseL( CStifItemParser* aItem ); + + /** + * Executes pause script line. + */ + TBool ExecutePauseL( CStifItemParser* aItem, CTestCase* aTestCase ); + + /** + * Executes complete script line. + */ + TBool ExecuteCompleteL( CStifItemParser* aItem, CTestCase* aTestCase ); + + /** + * Executes event set script line. + */ + TBool ExecuteEventSetL( CStifItemParser* aItem ); + + /** + * Executes event unset script line. + */ + TBool ExecuteEventUnsetL( CStifItemParser* aItem ); + + /** + * Executes event control command. + */ + TBool ExecuteEventCtlL( CStifItemParser* aItem, + TTCKeywords::TKeywords aKeyword ); + + /** + * Executes allocate script line. + */ + TBool ExecuteAllocateL( CStifItemParser* aItem ); + + /** + * Executes free script line. + */ + TBool ExecuteFreeL( CStifItemParser* aItem ); + + /** + * Frees slave. + */ + void ExecuteFreeL( CSlaveInfo* aSlave ); + + /** + * Executes remote script line. + */ + TBool ExecuteRemoteL( CStifItemParser* aItem ); + + /** + * Executes remote run script line. + */ + TBool ExecuteRemoteRunL( CStifItemParser* aItem, CSlaveInfo* aSlave, + HBufC *aSetUnsetEvent = NULL, + TInt aCaseNumber = 0 ); + + /** + * Executes remote test control script line. + */ + TBool ExecuteRemoteTestCtlL( CStifItemParser* aItem, + CTestCase* aTestCase, + TInt aCmd ); + + /** + * Executes remote event control script line. + */ + TBool ExecuteRemoteEventCtlL( CStifItemParser* aItem, + CSlaveInfo* aSlave, + TInt aCmd ); + + /** + * Executes remote event set unset line + */ + TBool ExecuteRemoteSetUnsetEventL( CStifItemParser* aItem, + CSlaveInfo* aSlave, + TInt aCmd ); + + /** + * Executes asynchronous remote sendreceive control script line. + */ + TBool ExecuteRemoteSendReceiveL( CStifItemParser* aItem, + CSlaveInfo* aSlave ); + + /** + * Executes remote unknown control script line. + */ + TBool ExecuteRemoteUnknownL( CStifItemParser* aItem, + CSlaveInfo* aSlave, + TDesC& aCommand ); + /** + * Handles received run responses from slave. + */ + TBool ReceiveResponseRunL( CStifTFwIfProt& aMsg ); + + /** + * Handles received test control responses from slave. + */ + TBool ReceiveResponseTestCtlL( CStifTFwIfProt& aMsg ); + + /** + * Handles received Event system control responses from slave. + */ + TBool ReceiveResponseEventCtlL( CStifTFwIfProt& aMsg ); + + /** + * Handles received asynchronous sendreceive responses from slave. + */ + TBool ReceiveResponseSendReceiveL( CStifTFwIfProt& aMsg ); + + /** + * Handles received responses for unspecified commands from slave. + */ + TBool ReceiveResponseUnknownL( CStifTFwIfProt& aMsg ); + + /** + * Check unset event we are waiting. + */ + TBool CheckUnsetEvent(); + + /** + * Parses optional argument. + */ + void ParseOptArgL( const TDesC& aOptArg, TPtrC& aArg, TPtrC& aVal); + + /** + * Preprocess hardcoded values in test case. + */ + CStifItemParser* PreprocessLineL( TDesC& line ); + + /** + * Checks if aWord is defined value. + */ + TInt CheckDefined( TPtrC& aWord ); + + /** + * Handle the loop keyword operations. + */ + void ExecuteLoopL( CStifItemParser* aItem ); + + /** + * Handle the endloop keyword operations. + */ + TBool ExecuteEndLoopL(); + + public: //Data + + protected: // Data + + private: // Data + // Runner state + TRunnerState iState; + + // Backpointer to CTestCombiner + CTestCombiner* iTestCombiner; + + // Event system control + TEventIf iEvent; + + // Pause timer + RTimer iPauseTimer; + TName iPausedTestCase; + TInt iPauseTime; + + // Pause combiner timer + RTimer iPauseCombTimer; + TInt iPauseCombRemainingTime; + + // Temporary line buffer + HBufC* iLine; + + // Remote control protocol timer + CRemoteTimer* iRemoteTimer; + + // Loop times, counter and start position + TInt iLoopTimes; + TInt iLoopCounter; + TInt iLoopStartPos; + TBuf<10> iLoopCounterDes; + TInt iEndLoopStartPos; + + // Loop passlimit (endurance) feature + TInt iPasslimit; + TBool iPasslimitEnabled; + TInt iPassedIterationCnt; + + // Loop (timed loop option) + TBool iTimedLoop; + TTime iStartTime; + TTimeIntervalMicroSeconds iExpectedLoopTime; + + // Message displayed when leave occurs during script parsing + TBuf<256> iRunErrorMessage; + public: // Friend classes + + protected: // Friend classes + + private: // Friend classes + friend class CTestCombiner; + + }; + +// CLASS DECLARATION +typedef TBuf<0x200> TRemoteProtMsg; + +// DESCRIPTION +// CTestRemoteReceiver handles remote protocol receiving +NONSHARABLE_CLASS(CRemoteReceiver) + :public CActive + { + public: // Enumerations + + private: // Enumerations + enum TReceiverState + { + EReceiverIdle, + EReceiverPending, + }; + + public: // Constructors and destructor + /** + * Two-phased constructor. + */ + static CRemoteReceiver* NewL( CTestCombiner* aTestCombiner ); + + /** + * Destructor. + */ + ~CRemoteReceiver(); + + public: // New functions + /** + * Calls SetActive() from CActive. + */ + void Start(); + + public: // Functions from base classes + /** + * RunL derived from CActive handles the completed requests. + */ + void RunL(); + + /** + * DoCancel derived from CActive handles the Cancel. + */ + void DoCancel(); + + protected: // New functions + + protected: // Functions from base classes + + private: + /** + * C++ default constructor. + */ + CRemoteReceiver( CTestCombiner* aTestCombiner ); + + /** + * By default Symbian OS constructor is private. + */ + void ConstructL(); + + public: //Data + + protected: // Data + + private: // Data + // Runner state + TReceiverState iState; + + // Backpointer to CTestCombiner + CTestCombiner* iTestCombiner; + + // Remote protocol message + TRemoteProtMsg iRemoteMsg; + + public: // Friend classes + + protected: // Friend classes + + private: // Friend classes + + }; + +// CLASS DECLARATION + +// DESCRIPTION +// CRemoteTimer handles remote protocol timeouts +NONSHARABLE_CLASS(CRemoteTimer) + :public CActive + { + public: // Enumerations + + private: // Enumerations + enum TTimerState + { + ETimerIdle, + ETimerPending, + }; + + public: // Constructors and destructor + /** + * Two-phased constructor. + */ + static CRemoteTimer* NewL( CTestCombiner* aTestCombiner ); + + /** + * Destructor. + */ + ~CRemoteTimer(); + + public: // New functions + /** + * Starts timer. + */ + void SetTimerActive( TTimeIntervalMicroSeconds32 anInterval ); + + public: // Functions from base classes + /** + * RunL derived from CActive handles the completed requests. + */ + void RunL(); + + /** + * DoCancel derived from CActive handles the Cancel. + */ + void DoCancel(); + + protected: // New functions + + protected: // Functions from base classes + + private: + /** + * C++ default constructor. + */ + CRemoteTimer( CTestCombiner* aTestCombiner ); + + /** + * By default Symbian OS constructor is private. + */ + void ConstructL(); + + public: //Data + + protected: // Data + + private: // Data + // Runner state + TTimerState iState; + + // Backpointer to CTestCombiner + CTestCombiner* iTestCombiner; + + // Pause timer + RTimer iTimer; + + public: // Friend classes + + protected: // Friend classes + + private: // Friend classes + + }; + + +// DESCRIPTION +// TTestMeasurement contains test measurement module information +class TTestMeasurement + { + public: + TTestMeasurement(){ iMeasurement = NULL; }; + ~TTestMeasurement(){ delete iMeasurement; }; + + public: + + public: + // "object" name given in test case file. + TName iName; + // MSTIFTestInterference object. + CSTIFTestMeasurement* iMeasurement; + + private: + + }; + +#endif // TESTCOMBINER_H + +// End of File