--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/stif/inc/TestServerModuleIf.h Wed Oct 13 16:17:58 2010 +0300
@@ -0,0 +1,693 @@
+/*
+* 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 CTestExecution.
+*
+*/
+
+#ifndef TEST_SERVER_MODULE_IF_H
+#define TEST_SERVER_MODULE_IF_H
+
+
+// INCLUDES
+#include <e32std.h>
+#include <e32base.h>
+#include <StifTestModule.h>
+#include <StifTestInterface.h>
+#include "StifTFwIfProt.h"
+
+// CONSTANTS
+
+// MACROS
+
+// DATA TYPES
+
+// FUNCTION PROTOTYPES
+typedef CSTIFTestMeasurementImplementation*(
+ *CTestMeasurementFactory )( const TDesC&,
+ CSTIFTestMeasurement::TSTIFMeasurementType );
+
+// FORWARD DECLARATIONS
+class TEvent;
+class CTestModule;
+class CTestModuleContainer;
+class CPrintQueue;
+class CPrintHandler;
+class CEventHandler;
+class CSndHandler;
+class CRcvHandler;
+class CErrorPrintHandler;
+class CInterferenceHandler;
+class CMeasurementHandler;
+class CCommandHandler;
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// TCmdDef represents remote command
+class TCmdDef
+ {
+ public:
+ TStifCommand iCommand;
+ TParams iParam;
+ TInt iLen;
+ TRequestStatus* iStatus;
+ };
+
+// TCommandDef represents command
+class TCommandDef
+ {
+ public:
+ TCommand iCommand;
+ TBuf8<KMaxCommandParamsLength2> iParamsPckg;
+ };
+
+// DESCRIPTION
+// CCommandDef represents command
+class CCommandDef : public CBase
+ {
+ public: // Enumerations
+
+ private: // Enumerations
+
+ public: // Constructors and destructor
+ static CCommandDef* NewL();
+ ~CCommandDef();
+
+ private: // Constructors and destructor
+ CCommandDef();
+ void ConstructL();
+
+ public: // New functions
+
+ public: // Functions from base classes
+
+ protected: // New functions
+
+ protected: // Functions from base classes
+
+ private:
+
+ public: //Data
+ TCommand iCommand;
+ TBuf8<KMaxCommandParamsLength2> iParamsPckg;
+
+ protected: // Data
+
+ private: // Data
+
+ public: // Friend classes
+
+ protected: // Friend classes
+
+ private: // Friend classes
+
+ };
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// TCmdDef represents remote command
+class TEventDef
+ {
+ public:
+ enum TEventCmdType
+ {
+ EEventCmd,
+ EEventCmdCancel,
+ };
+ // Added constructor to TEventDef @js
+ TEventDef():iStatus(NULL){};
+
+ public:
+ TEventCmdType iType;
+ TEventIf iEvent;
+ TRequestStatus* iStatus;
+ };
+
+// DESCRIPTION
+// TTestInterference represents remote command
+class TTestInterference
+ {
+ public:
+ enum TOperation
+ {
+ EAppend,
+ ERemove,
+ };
+ public:
+ TTestInterference(){};
+ public:
+ // Thread id.
+ TUint iThreadId;
+ // Is operations append or remove.
+ TOperation iOperation;
+ };
+
+// DESCRIPTION
+// TTestMeasurement contains measurement related information
+// transfering between TestInterface and TestServer.
+class TTestMeasurement
+ {
+ public:
+ TTestMeasurement(){};
+ public:
+ // Struct for information.
+ CSTIFTestMeasurement::TStifMeasurementStruct iMeasurementStruct;
+
+ };
+
+// DESCRIPTION
+// TMeasurementHandling keeps information for measurement module
+// dynamic loading, types, etc.
+class TMeasurementHandling
+ {
+ public:
+ TMeasurementHandling() : iMeasurement( NULL ),
+ iMeasurementModulePtr( NULL ){};
+
+ ~TMeasurementHandling()
+ {
+ delete iMeasurement;
+ delete iMeasurementModulePtr;
+ // After close test measurement's pointer is not valid anymore.
+ if ( iMeasurementModule.Handle() )
+ {
+ iMeasurementModule.Close();
+ }
+ };
+ public:
+ RLibrary iMeasurementModule;
+ CTestMeasurementFactory iMeasurementLibEntry;
+ CSTIFTestMeasurementImplementation* iMeasurement;
+ CSTIFTestMeasurement::TSTIFMeasurementType iMeasurementType;
+ CSTIFTestMeasurementImplementation* iMeasurementModulePtr;
+ };
+
+// CLASS DECLARATION
+
+// DESCRIPTION
+// CTestExecution represents a subsession object in the CTestServer.
+// A session may own any number of CTestExecution objects
+class CTestExecution
+ :public CObject
+ {
+
+ public: // Enumerations
+ enum TTestState
+ {
+ ENotStarted,
+ EOnGoing,
+ EFinished,
+ ECancelled,
+ };
+
+ enum TRequestType
+ {
+ ERqPrint,
+ ERqEvent,
+ ERqSnd,
+ ERqRcv,
+ ERqInterference,
+ ERqMeasurement,
+ ERqCommand,
+ };
+
+ enum TTestThreadFailure
+ {
+ ETestThreadOk = 0,
+ ETestMemLeak = 0x00000001,
+ ETestRequestLeak = 0x00000002,
+ ETestHandleLeak = 0x00000004,
+ };
+
+ private: // Enumerations
+ // None
+
+ public: // Constructors and destructor
+
+ /**
+ * NewL is first phase of two-phased constructor.
+ */
+ static CTestExecution* NewL( CTestModule* aModuleSession,
+ TInt aCaseNumber,
+ const TFileName& aConfig
+ );
+
+ /**
+ * Destructor
+ */
+ virtual ~CTestExecution();
+
+ public: // New functions
+
+ /**
+ * Close Test Execution
+ */
+ TInt CloseTestExecution( const RMessage2& aMessage );
+
+ /**
+ * Run a test case
+ */
+ TInt RunTestCase( const RMessage2& aMessage );
+
+ /**
+ * Sets a print notification
+ */
+ TInt NotifyPrint( const RMessage2& aMessage );
+
+ /**
+ * Sets a event notification
+ */
+ TInt NotifyEvent( const RMessage2& aMessage );
+
+ /**
+ * Sets a RemoteCmd notification
+ */
+ TInt NotifyRemoteCmd( const RMessage2& aMessage );
+
+ /**
+ * Reads a RemoteCmd notification
+ */
+ TInt ReadRemoteCmdInfo( const RMessage2& aMessage );
+
+ /**
+ * Resumes a paused test case
+ */
+ TInt Resume( const RMessage2& aMessage );
+
+ /**
+ * Pauses ongoing test case
+ */
+ TInt Pause( const RMessage2& aMessage );
+
+
+ /**
+ * Cancels asynchronous request
+ */
+ TInt CancelRequestL( const RMessage2& aMessage );
+
+
+ /**
+ * Completes a print request.
+ */
+ void DoNotifyPrint();
+
+ /**
+ * Completes a interference request.
+ */
+ void DoNotifyInterference();
+
+ /**
+ * Completes a measurement request.
+ */
+ TInt DoNotifyMeasurement();
+
+ /**
+ * Completes a print request.
+ */
+ void DoErrorPrint();
+
+ /**
+ * Enables remote command receiving.
+ */
+ void DoRemoteReceive();
+
+ /**
+ * Sends remote commands.
+ */
+ void DoRemoteSend();
+
+ /**
+ * Completes a event request.
+ */
+ TInt DoNotifyEvent();
+
+ /**
+ * Completes a event cancel request.
+ */
+ void CancelEvent();
+
+ /**
+ * Set thread State.
+ * This function can be called from test execution thread.
+ */
+ void SetThreadState( const TTestState aState );
+
+ /**
+ * Completes print request if print queue is empty
+ */
+ void CompletePrintRequestIfQueueEmpty();
+
+ /**
+ * Completes print request if print queue is empty
+ */
+ void CleanupEvents();
+
+ /**
+ * Completes test execution
+ */
+ void CompleteTestExecution( const TInt aCompletionCode,
+ const TFullTestResult::TCaseExecutionResult aCaseExecutionType,
+ const TInt aCaseExecutionCode,
+ const TInt aCaseResult,
+ const TDesC& aText );
+
+ /**
+ * Unsets all pending state events.
+ */
+ void UnsetStateEvents();
+
+ /**
+ * Completes test execution
+ */
+ void CompleteTestExecution( const TInt aCompletionCode );
+
+ /**
+ * Current thread state.
+ */
+ TTestState ThreadState(){ return iThreadState; }
+
+ /**
+ * Cancels test(s) execution in special cases e.g. timeout, exit etc.
+ */
+ TInt CancelTestExecution();
+
+ /**
+ * Make sure that any of the test interference thread's won't stay
+ * to run if test case is crashed of test interference object is not
+ * deleted.
+ */
+ TInt KillTestinterferenceThread();
+
+ /**
+ * Make sure that any of the test measurement process's won't stay
+ * to run if test case is crashed of test measurement object is not
+ * deleted.
+ */
+ TInt KillTestMeasurement();
+
+ /**
+ * Executes command for ongoing test case.
+ * Created to allow test case to kill itself.
+ */
+ TInt NotifyCommand(const RMessage2& aMessage);
+
+ /**
+ * Completes a command request.
+ * Created to allow test case to kill itself.
+ */
+ TInt DoNotifyCommand();
+
+ /**
+ * Cancels command request.
+ * Created to allow test case to kill itself.
+ */
+ TInt CancelCommandRequest();
+
+ /**
+ * Get test case arguments.
+ */
+ const TDesC& GetTestCaseArguments() const;
+
+ public: // Functions that are called from test thread
+
+ /**
+ * Get mutex handles.
+ */
+ TInt EventMutexHandle(){ return iEventMutex.Handle(); };
+ TInt SndMutexHandle(){ return iSndMutex.Handle(); };
+ TInt RcvMutexHandle(){ return iRcvMutex.Handle(); };
+ TInt PrintMutexHandle(){ return iPrintMutex.Handle(); };
+ TInt InterferenceMutexHandle(){ return iInterferenceMutex.Handle(); };
+ TInt MeasurementMutexHandle(){ return iMeasurementMutex.Handle(); };
+ TInt CommandMutexHandle(){ return iCommandMutex.Handle(); };
+
+ /**
+ * Get semaphore handles.
+ */
+ TInt EventSemHandle(){ return iEventSem.Handle(); };
+ TInt SndSemHandle(){ return iSndSem.Handle(); };
+ TInt RcvSemHandle(){ return iRcvSem.Handle(); };
+ //TInt ReceiverSemHandle(){ return iReceiverSem.Handle(); };
+ TInt PrintSemHandle(){ return iPrintSem.Handle(); };
+ TInt InterferenceSemHandle(){ return iInterferenceSem.Handle(); };
+ TInt MeasurementSemHandle(){ return iMeasurementSem.Handle(); };
+ TInt CommandSemHandle(){ return iCommandSem.Handle(); };
+
+ /**
+ * Set execution test thread id.
+ */
+ void SetTestThread( TThreadId aThreadId ){ iTestThreadId = aThreadId; };
+
+ /**
+ * Access to "shared" memory.
+ */
+ TFullTestResult& FullResult(){ return iFullResult; };
+ TTestProgress& TestProgress(){ return iProgress; };
+ TEventDef& EventDef(){ return iEventDef; };
+ TCmdDef& SndInfo(){ return iCmdDef; };
+ TCmdDef& RcvInfo(){ return iRcvCmdDef; };
+ TInt& TestThreadFailure(){ return iTestThreadFailure; };
+ TTestInterference& TestInterference(){ return iTestInterference; };
+ TTestMeasurement& TestMeasurement(){ return iTestMeasurement; };
+ CCommandDef& CommandDef(){ return *iCommandDef; };
+
+ /**
+ * Get specific TRequestStatus variable.
+ */
+ TRequestStatus* GetRq( TRequestType aType );
+
+ /**
+ * Get mutex handle.
+ * This mutex meaning is to make sure that test complete and test
+ * case cancel operations are not executed at the same time.
+ */
+ TInt TestThreadMutexHandle() { return iTestThreadMutex.Handle(); };
+
+ const TDesC& GetConfigFileName() const { return iConfig; }
+ public: // Functions from base classes
+ // None
+
+ protected: // New functions
+ // None
+
+ protected: // Functions from base classes
+ // None
+
+ private:
+
+ /**
+ * C++ default constructor.
+ */
+ CTestExecution();
+
+ /**
+ * By default Symbian OS constructor is private.
+ */
+ void ConstructL( CTestModule* aModuleSession,
+ TInt aCaseNumber,
+ const TFileName& aConfig );
+
+ /**
+ * Cancels print request.
+ */
+ TInt CancelPrintRequest();
+
+ /**
+ * Cancels test interference request.
+ */
+ TInt CancelInterferenceRequest();
+
+ /**
+ * Cancels test execution request
+ */
+ TInt CancelTestRequest();
+
+ /**
+ * Cancel event request.
+ */
+ TInt CancelEventRequest();
+
+ /**
+ * Cancel event request.
+ */
+ TInt CancelRemoteCmdRequest();
+
+ /**
+ * Writes a print notification to client memory space.
+ */
+ TInt WritePrint( TTestProgress& aProgress );
+
+ /**
+ * Complete event TRequestStatus if pending.
+ */
+ void CompleteEvent( TInt aError );
+
+ /**
+ * Handle event unsets.
+ */
+ TInt UnsetEvent( TEventIf& aEvent, const RMessage2& aMessage );
+
+ /**
+ * Handle event request.
+ */
+ TInt RequestEvent( TEventIf& aEvent );
+
+ /**
+ * Wait event request.
+ */
+ TInt WaitEvent( TEventIf& aEvent, TRequestStatus* aStatus );
+
+ /**
+ * Handle event releases.
+ */
+ TInt ReleaseEvent( TEventIf& aEvent );
+
+ /**
+ * Handle state events.
+ */
+ TInt EventStateChange( TEventIf& aEvent );
+
+ /**
+ * Complete request in test thread.
+ */
+ void TestThreadRequestComplete( TRequestStatus* aStatus, TInt aCode );
+
+ public: // Data
+ // None
+ protected: // Data
+ // None
+
+ private: // Data
+
+ // Pointers to things around
+ CTestModule* iModuleSession; // Session owning us
+ CTestModuleContainer* iModuleContainer; // Container used to execute this case
+
+ // Test execution related members
+ TInt iCaseNumber; // Case to be executed
+ TPtr iConfig; // Configuration file name
+ HBufC* iConfigNameBuffer; // HBuffer for configuration file;
+ HBufC* iTestCaseArgs; // HBuffer for test case arguments
+
+ RMessage2 iTestExeMessage; // Test execution message
+ TTestState iThreadState; // Thread state
+
+ // Print related members
+ RMutex iPrintMutex; // For iPrintSem semaphore handling
+ RSemaphore iPrintSem; // Synchonize print queue access
+ CPrintQueue* iPrintQueue; // Print queue
+ RMessage2 iNotifyPrintMessage; // Print notification message
+ TBool iPrintNotifyAvailable; // Is print notification available?
+
+ // Event related members
+ RMessage2 iNotifyEventMessage; // Event nofitication message
+ TBool iEventNotifyAvailable; // Is event notification available?
+ RMutex iEventMutex; // For iEventSem semaphore handling
+ RSemaphore iEventSem; // Signal event request availability
+ TEventDef iEventDef;
+
+ // Remote command protocol related stuff
+ RMessage2 iNotifyRemoteCmdMessage;// RemoteCmd notication message
+ TBool iRemoteSendAvailable; // Is RemoteSend available
+ RMutex iSndMutex; // For iSndSem semaphore handling
+ RSemaphore iSndSem; // Signal RemoteCmd request availability
+ TThreadId iTestThreadId; // Thread id for receiver
+ RThread iTestThread;
+ TBool iTestThreadOpen;
+ TBool iRemoteReceiveAvailable; // Is RemoteReceive available
+ RMutex iRcvMutex; // For iRcvSem semaphore handling
+ RSemaphore iRcvSem; // Signal RemoteCmd request availability
+ //RSemaphore iReceiverSem; // Signal testmodule request availability
+ RPointerArray<HBufC8> iMessageQueue;
+
+ TCmdDef iCmdDef;
+ TCmdDef iRcvCmdDef;
+ TTestProgress iProgress;
+
+
+ // Result with timestamp information
+ TFullTestResult iFullResult;
+ TInt iTestThreadFailure;
+
+ // Event array
+ RPointerArray<TEvent> iEventArray;
+ // State event array
+ RPointerArray<TDesC> iStateEvents;
+
+ // Event handlers
+ CPrintHandler* iPrintHandler;
+ CEventHandler* iEventHandler;
+ CSndHandler* iSndHandler;
+ CRcvHandler* iRcvHandler;
+ CInterferenceHandler* iInterferenceHandler;
+ CMeasurementHandler* iMeasurementHandler;
+ CCommandHandler* iCommandHandler;
+
+ // Test Interface related members
+ RMutex iInterferenceMutex; // For iInterferenceMutex semaphore handling
+ RSemaphore iInterferenceSem; // Synchronize interference queue access
+ TBool iInterferenceNotifyAvailable; // Is interference notification
+ //available?
+ // Test measurement related members
+ RMutex iMeasurementMutex; // For iMeasurementMutex semaphore handling
+ RSemaphore iMeasurementSem; // Synchronize measurement queue access
+ TBool iMeasurementNotifyAvailable; // Is measurement notification
+ //available?
+ RMessage2 iNotifyInterferenceMessage; // Interference notification message
+
+ TTestInterference iTestInterference; // Struct for information
+ // Array for handling test interference thread's kill in
+ // panic etc. cases
+ RArray<RThread> iSTIFTestInterferenceArray;
+
+ RMessage2 iNotifyMeasurementMessage; // Measurement notification message
+
+ // Struct for information
+ TTestMeasurement iTestMeasurement;
+ // Array for handling measurement
+ RPointerArray<TMeasurementHandling> iMeasurementHandlingArray;
+
+ // This mutex meaning is to make sure that test complete and test
+ // case cancel operations are not executed at the same time.
+ RMutex iTestThreadMutex;
+
+ // Command related members
+ CCommandDef* iCommandDef; // Command definition (content)
+ RMessage2 iNotifyCommandMessage; // Command nofitication message
+ TBool iCommandNotifyAvailable; // Is command notification available?
+ RMutex iCommandMutex; // For iCommandSem semaphore handling
+ RSemaphore iCommandSem; // Signal command request availability
+
+ public: // Friend classes
+ // None
+
+ protected: // Friend classes
+ // None
+
+ private: // Friend classes
+ friend class CUnderTaker;
+ friend class CPrintHandler;
+ friend class CEventHandler;
+ friend class CSndHandler;
+ friend class CRcvHandler;
+ friend class TEvent;
+ friend class CInterferenceHandler;
+ friend class CMeasurementHandler;
+ friend class CCommandHandler;
+ };
+
+#endif // TEST_SERVER_MODULE_IF_H
+
+// End of File