--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/stif/TestServer/src/TestModuleContainer.cpp Wed Oct 13 16:17:58 2010 +0300
@@ -0,0 +1,2364 @@
+/*
+* 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 module contains implementation of
+* CTestModuleContainer class member functions. CTestModuleContainer
+* class contains interface * to execute various functions in context
+* of test execution thread.
+*
+* CTestModuleContainer is the owner of the test execution thread
+* object and the owner of the test module instance.
+*
+*/
+
+// INCLUDE FILES
+#include <e32std.h>
+#include <e32svr.h>
+#include <e32uid.h>
+#include "TestEngineClient.h"
+#include <StifTestModule.h>
+#include <stifinternal/TestServerClient.h>
+#include "TestServer.h"
+#include "TestServerModuleIf.h"
+#include "TestServerCommon.h"
+#include "PrintQueue.h"
+#include "TestThreadContainer.h"
+//--PYTHON-- begin
+#include "StifPython.h"
+//--PYTHON-- end
+
+// EXTERNAL DATA STRUCTURES
+
+// EXTERNAL FUNCTION PROTOTYPES
+
+// The test module execution thread function
+TInt ExecutionThread( TAny* aParams );
+
+// CONSTANTS
+
+// MACROS
+
+// LOCAL CONSTANTS AND MACROS
+
+// MODULE DATA STRUCTURES
+
+// LOCAL FUNCTION PROTOTYPES
+typedef TInt( *CTestInterfaceFactoryTestModule )( CTestModuleParam*&, TUint32& );
+
+// FORWARD DECLARATIONS
+
+// ==================== LOCAL FUNCTIONS =======================================
+
+// ================= MEMBER FUNCTIONS =========================================
+
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: NewL
+
+ Description: Returns new CTestModuleContainer instance.
+
+ Parameters: const TDesC& aName: in: Module name
+ CTestModule* aSession: in: "Parent"
+ const TDesC& aConfig: in: Test case (config) file name.
+
+ Return Values: CTestModuleContainer* New instance
+
+ Errors/Exceptions: Function leaves if memory allocation fails or
+ CTestModuleContainer ConstructL leaves.
+ Panics if aSession is NULL.
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CTestModuleContainer* CTestModuleContainer::NewL( const TDesC& aName,
+ CTestModule* aSession,
+ const TDesC& aConfig )
+ {
+
+ __ASSERT_ALWAYS ( aSession,
+ CTestServer::PanicServer( ENullTestModule ) );
+
+ CTestModuleContainer* self = new ( ELeave ) CTestModuleContainer();
+ CleanupStack::PushL( self );
+ self->ConstructL( aName, aSession, aConfig );
+ CleanupStack::Pop( self );
+ return self;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: ConstructL
+
+ Description: Second level constructor.
+
+ Function creates the execution thread, creates exception
+ handler and the thread undertaker for it and then resumes the thread.
+
+ Parameters: const TDesC& aName: in: Module name
+ CTestModule* aSession: in: "Parent"
+ const TDesC& aConfig: in: Test case (config) file name.
+
+ Return Values: CTestModuleContainer* New instance
+
+ Errors/Exceptions: Function leaves if thread creation fails,
+ memory allocation fails or undertaker creation leaves.
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::ConstructL( const TDesC& aName,
+ CTestModule* aSession,
+ const TDesC& aConfig )
+ {
+
+ RDebug::Print( aName );
+
+ iNestedActiveScheduler = new (ELeave) CActiveSchedulerWait;
+
+ iCTestModule = aSession;
+
+ // Create error print handler
+ iErrorPrintHandler = CErrorPrintHandler::NewL( *this );
+ User::LeaveIfError( iErrorPrintSem.CreateLocal( 0 ) );
+
+ // Construct unique thread name
+ const TInt KAddressLen = 8;
+ const TInt KMaxName = 50; // Something smaller than max thread name
+ TInt len = aName.Length();
+ if ( KAddressLen + len > KMaxName )
+ {
+ len = KMaxName - KAddressLen;
+ }
+
+ // Default heap and stack sizes that may configure by user.
+ TInt heapMinSize( KTestThreadMinHeap );
+ TInt heapMaxSize( KTestThreadMaxHeap );
+ TInt stackSize( KStackSize );
+
+ // Check is user give heap or stack sizes and verify sizes.
+ GetTestModuleParams( aName, aConfig, stackSize, heapMinSize, heapMaxSize );
+
+ // Create a new thread
+ TInt ret = KErrAlreadyExists;
+ for( TInt i = 0; ret == KErrAlreadyExists; i++ )
+ {
+ TName threadName = aName.Left( len );
+ threadName.AppendFormat( _L( "%x" ), ( TUint32 ) this );
+ threadName.AppendFormat( _L( "%x" ), i );
+ //RDebug::Print( threadName );
+
+ RDebug::Print(_L("CTestModuleContainer::ConstructL create thread=[%S] stackSize=(%d)"), &threadName, stackSize);
+
+ if ( iCTestModule->GetTestServer()->UiTesting() == false )
+ {
+ ret = iThread.Create(
+ threadName, // name of thread
+ CTestThreadContainer::ExecutionThread,// thread function
+ stackSize, // Stack size
+ heapMinSize, // Heap sizes
+ heapMaxSize,
+ this // Parameter to thread function
+ );
+ }
+ else
+ {
+ ret = iThread.Create(
+ threadName, // name of thread
+ CTestThreadContainer::UIExecutionThread,// thread function
+ stackSize, // Stack size
+ heapMinSize, // Heap sizes
+ heapMaxSize,
+ this // Parameter to thread function
+ );
+ }
+
+ // If test execution thread exist try to create new one
+ if( ret == KErrAlreadyExists )
+ {
+ RDebug::Print( _L( "Thread[%S] allready exist, creating new one" ), &threadName );
+ __TRACE ( KInit, ( CStifLogger::ERed, _L( "Thread[%S] allready exist, creating new one" ), &threadName ) );
+ }
+
+ }
+
+ // If thread creation fails, leave here.
+ if( ret != KErrNone )
+ {
+ RDebug::Print( _L( "Execution thread creation fails with: [%d]" ), ret );
+ __TRACE ( KError, ( CStifLogger::ERed, _L( "Execution thread creation fails with: [%d]" ), ret ) );
+ User::Leave( ret );
+ }
+
+ // Doing nothing
+ // ChangeOperationNoError ( ESuspend, 0 );
+ // Thread suspends always first by default
+
+ // Construct the undertaker to get notifications about the
+ // thread death.
+ // This must be trapped to allow to kill just created thread
+ // nicely without a mess in destructor.
+ TRAPD ( r,
+ iUnderTaker = CUnderTaker::NewL ( this );
+ CActiveScheduler::Add( iUnderTaker );
+ iUnderTaker->StartL();
+ );
+
+ // Can't create or start the undertaker. Kill the thread.
+ // Undertaker will be deleted in destructor if needed.
+ if ( r != KErrNone )
+ {
+ iThread.Kill ( r );
+ iThread.Close();
+ User::Leave( r );
+ }
+
+ // Get server thread id ( i.e current thread id )
+ RThread tmpThread;
+ iServerThreadId = tmpThread.Id();
+
+ // Resume the thread
+ iThread.Resume(); // Start the thread
+ iUpAndRunning = ETrue; // Thread is created
+
+ // Add "this" container to active scheduler
+ CActiveScheduler::Add ( this );
+
+ // Start error print handler
+ iErrorPrintHandler->StartL();
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: CTestModuleContainer
+
+ Description: Constructor.
+
+ Initialise semaphores.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CTestModuleContainer::CTestModuleContainer() :
+ CActive( CActive::EPriorityStandard ),
+ iOperationName ( 0, 0 ),
+ iIsPaused( EFalse )
+ {
+
+ // Create operation start semaphore
+ iOperationStartSemaphore.CreateLocal( 0 );
+
+ // Operation can be changed without first waiting.
+ iOperationChangeSemaphore.CreateLocal( 1 );
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: ~CTestModuleContainer
+
+ Description: Destructor
+
+ Delete the test execution thread, if it is up and running. Delete
+ undertaker and close handles.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CTestModuleContainer::~CTestModuleContainer()
+ {
+
+ __TRACE ( KThreadOperation, ( _L( "CTestModuleContainer::~CTestModuleContainer in" ) ) );
+
+ if ( iUpAndRunning )
+ {
+ if( iUnderTaker != NULL )
+ {
+ iUnderTaker->Cancel();
+ }
+
+ // Set the operation
+ ChangeOperationNoError ( EExit, 0 );
+
+ // Do operation
+ StartAndWaitOperation();
+
+ }
+
+ delete iErrorPrintHandler;
+ iErrorPrintHandler = NULL;
+
+ // Delete heap descriptor
+ delete iModuleNameBuffer;
+ iModuleNameBuffer = NULL;
+
+ // Delete undertaker
+ delete iUnderTaker;
+ iUnderTaker = NULL;
+
+ // Close error semaphore
+ if ( iErrorPrintSem.Handle() != 0 ) iErrorPrintSem.Close();
+
+ // Close the semaphores
+ iOperationStartSemaphore.Close();
+ iOperationChangeSemaphore.Close();
+
+ // Close handle to thread
+ iThread.Close();
+
+ Cancel();
+
+ delete iNestedActiveScheduler;
+ iNestedActiveScheduler = NULL;
+
+ __TRACE ( KThreadOperation, ( _L( "CTestModuleContainer::~CTestModuleContainer out" ) ) );
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: StartAndWaitOperation
+
+ Description: Signals operation and waits until operation is completed.
+
+ Function executes active scheduler locally to handle both request
+ completion from execution thread and thread undertaker operations.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::StartAndWaitOperation()
+ {
+
+ // Change undertaker mode to synchronous
+ iUnderTaker->SetSynchronousMode( ETrue );
+
+ iStatus = KRequestPending;
+ // Get ready to handle operation completion
+ SetActive();
+
+ // Start operation
+ iOperationStartSemaphore.Signal();
+
+ // Start "nested" active scheduler "locally"
+ //CActiveScheduler::Start();
+ iNestedActiveScheduler->Start();
+
+ // Request completed or operation crashed, everything
+ // is done in ModuleContainer's RunL function or in UnderTaker's RunL.
+
+ // Cancel the original request in case than it was the undertaker
+ // that stopped the active scheduler. Does not do anything if original
+ // request is already finished.
+ Cancel();
+
+ // Undertaker back to "normal" mode
+ iUnderTaker->SetSynchronousMode ( EFalse );
+
+ return iModuleResult;
+
+ }
+
+
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: Initialise
+
+ Description: Initialise the test module
+
+ Initialisation is done in context of test execution thread.
+
+ Parameters: const TDesC& aName :in: Module name
+ TBool aFirstTime :in: First init?
+
+
+ Return Values: TInt Result from init
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::Initialize( const TFileName& aName,
+ TBool aFirstTime
+ )
+ {
+
+ __TRACE ( KInit, ( _L( "Initializing test module" ) ) );
+
+ // Set the operation
+ iErrorResult = ChangeOperation ( EInitializeModule, aName, aFirstTime );
+ iModuleResult = KErrNone;
+
+ if ( iErrorResult == KErrNone )
+ {
+ // Wait until operation is completed
+ StartAndWaitOperation();
+ }
+
+ if ( iErrorResult )
+ {
+ __TRACE ( KError, ( CStifLogger::ERed, _L( "Initializing test module failed %d" ), iErrorResult ) );
+ }
+ else if ( iModuleResult )
+ {
+ __TRACE ( KError, ( CStifLogger::ERed, _L( "Initializing test module failed code from module = %d" ), iModuleResult ) );
+ }
+ else
+ {
+ __TRACE ( KInit, ( CStifLogger::EBold, _L( "Test module initialization done" ) ) );
+ }
+
+ // Return result
+ return iModuleResult;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: EnumerateTestCases
+
+ Description: Enumerate test cases of the test module
+
+ Enumeration is done in context of test execution thread.
+
+ Parameters: const TDesC& aName :in: Configuration file
+
+ Return Values: TInt Result from enumeration
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::EnumerateTestCases( const TFileName& aName )
+ {
+
+ __TRACE ( KInit, ( CStifLogger::EBold, _L( "Enumerating test cases from [%S] (might be empty)" ), &aName ) );
+
+ // Set the operation
+ iErrorResult = ChangeOperation( EEnumerateInThread, aName, 0 );
+ iModuleResult = KErrNone;
+
+ if ( iErrorResult == KErrNone )
+ {
+ // Wait until operation is completed
+ StartAndWaitOperation();
+ }
+
+ if ( iErrorResult )
+ {
+ __TRACE ( KError, ( CStifLogger::ERed, _L( "Enumerating test cases failed %d" ), iErrorResult ) );
+ }
+ else if ( iModuleResult )
+ {
+ __TRACE ( KError, ( CStifLogger::ERed, _L( "Enumerating test cases failed, code from module = %d" ), iModuleResult ) );
+ }
+ else
+ {
+ __TRACE ( KInit, ( _L( "Enumerating test cases done" ) ) );
+ }
+
+ // Return result
+ return iModuleResult;
+
+ }
+
+
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: FreeEnumerationData
+
+ Description: Frees the enumeration data
+
+ Memory deallocation is done in context of test execution thread.
+
+ Parameters: None
+
+ Return Values: TInt Result from operation
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+
+TInt CTestModuleContainer::FreeEnumerationData()
+ {
+
+ // Set the operation
+ ChangeOperationNoError( EFreeEnumerationData, 0 );
+
+ // Do the operation
+ StartAndWaitOperation();
+
+ // Return result
+ return iModuleResult;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: RunTestCase
+
+ Description: Run a test case
+
+ Running a test case is done in context of test execution thread. This
+ function is asynchronous ( i.e test is not finished when this function
+ returns ).
+
+ Parameters: const TFileName& aName :in: Configuration file
+ TInt aCaseNumber :in: Case number
+ const RMessage :in: Handle to test msg.
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::RunTestCase ( const TFileName& aName,
+ const TInt aCaseNumber,
+ const RMessage2& aMessage
+ )
+ {
+
+ __TRACE ( KInit, ( CStifLogger::EBold, _L( "Running test case [%S], case [%d]" ), &aName, aCaseNumber ) );
+
+ // Set the operation
+ iErrorResult = ChangeOperation( EExecuteTestInThread, aName, aCaseNumber );
+
+ if ( iErrorResult != KErrNone )
+ {
+ aMessage.Complete ( iErrorResult );
+ return;
+ }
+
+ // Set data
+ iMessage = aMessage;
+
+ iStatus = KRequestPending;
+ // Get ready to handle operation completion
+ SetActive();
+
+ // Do operation
+ iOperationStartSemaphore.Signal();
+
+ // This is asynchronous operation,
+ // do not wait until completed.
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: SetExecutionSubSession
+
+ Description: Set execution subsession
+
+ Sets module container test execution subsession. Execution subsession
+ is changed when a module container is reused to run another
+ test case.
+
+ Parameters: CTestExecution* aExecution :in: Subsession pointer
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::SetExecutionSubSession( CTestExecution* aExecution )
+ {
+
+ iCTestExecution = aExecution;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: PauseThread
+
+ Description: Pauses the thread
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::PauseThread()
+ {
+
+ if( iThread.ExitType() != EExitPending )
+ {
+ // Thread is not alive anymore
+ return KErrDied;
+ }
+
+ if(iCTestExecution != NULL)
+ {
+ RMutex printMutex;
+ printMutex.SetHandle( iCTestExecution->PrintMutexHandle() );
+ RMutex eventMutex;
+ eventMutex.SetHandle( iCTestExecution->EventMutexHandle() );
+ RMutex sndMutex;
+ sndMutex.SetHandle( iCTestExecution->SndMutexHandle() );
+ RMutex rcvMutex;
+ rcvMutex.SetHandle( iCTestExecution->RcvMutexHandle() );
+
+ printMutex.Wait(); // wait that print operation is done
+ eventMutex.Wait(); // wait that event operation is done
+ sndMutex.Wait(); // wait that and operation is done
+ rcvMutex.Wait(); // wait that event operation is done
+
+ iThread.Suspend();
+
+ printMutex.Signal();
+ eventMutex.Signal();
+ sndMutex.Signal();
+ rcvMutex.Signal();
+ }
+ else
+ {
+ __TRACE( KError,( _L( "STIF internal error - iCTestExecution is NULL in CTestModuleContainer::PauseThread" ) ) );
+ User::Panic(_L("NULL pointer exception"), KErrGeneral);
+ }
+
+ iIsPaused = ETrue;
+
+ return KErrNone;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: ResumeThread
+
+ Description: Resumes the thread
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::ResumeThread()
+ {
+
+ if( iThread.ExitType() != EExitPending )
+ {
+ // Thread is not alive anymore
+ return KErrDied;
+ }
+
+ iThread.Resume();
+
+ // Pause() - Resume() operations done successfully.
+ iIsPaused = EFalse;
+
+ return KErrNone;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: KillThread
+
+ Description: Kills the thread
+
+ Parameters: const TInt aCode :in: Kill code
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::KillThread( const TInt aCode )
+ {
+
+ iUpAndRunning = EFalse;
+ iUnderTaker->Cancel();
+
+ if(iCTestExecution != NULL)
+ {
+ RMutex printMutex;
+ printMutex.SetHandle( iCTestExecution->PrintMutexHandle() );
+ RMutex eventMutex;
+ eventMutex.SetHandle( iCTestExecution->EventMutexHandle() );
+ RMutex sndMutex;
+ sndMutex.SetHandle( iCTestExecution->SndMutexHandle() );
+ RMutex rcvMutex;
+ rcvMutex.SetHandle( iCTestExecution->RcvMutexHandle() );
+
+ printMutex.Wait(); // wait that print operation is done
+ eventMutex.Wait(); // wait that event operation is done
+ sndMutex.Wait(); // wait that snd operation is done
+ rcvMutex.Wait(); // wait that event operation is done
+
+ iThread.Kill ( aCode );
+
+ printMutex.Signal();
+ eventMutex.Signal();
+ sndMutex.Signal();
+ rcvMutex.Signal();
+ }
+ else
+ {
+ __TRACE( KError,( _L( "STIF internal error - iCTestExecution is NULL in CTestModuleContainer::KillThread" ) ) );
+ User::Panic(_L("NULL pointer exception"), KErrGeneral);
+ }
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: ChangeOperation
+
+ Description: Multithread safe way to change operation
+
+ Parameters: const TOperation aOperation :in: Operation type
+ const TFileName* aNameBuffer :in: Filename ( or NULL )
+ const TInt aInt :in: Operation specific int
+
+ Return Values: TInt Error code
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::ChangeOperation( const TOperation aOperation,
+ const TFileName& aNameBuffer,
+ const TInt aInt )
+ {
+
+ TInt ret = KErrNone;
+
+ iOperationChangeSemaphore.Wait();
+
+ iErrorResult = KErrNone;
+ iModuleResult = KErrNone;
+
+ TFileName newNameBuffer;
+ // Check is TestScripter
+ TInt check = CheckModuleName( aNameBuffer, newNameBuffer );
+ delete iModuleNameBuffer;
+ iModuleNameBuffer = NULL;
+ if( check == KErrNone )
+ {
+ // Construct heap buffer for configuration file
+ TRAP( ret, iModuleNameBuffer = HBufC::NewL( newNameBuffer.Length() ) );
+
+ if( ret == KErrNone )
+ {
+ iOperationName.Set ( iModuleNameBuffer->Des() );
+ iOperationName.Copy ( newNameBuffer );
+
+ iOperationIntBuffer = aInt;
+ iOperationType = aOperation;
+ }
+ else
+ {
+ __TRACE ( KError, ( CStifLogger::ERed, _L( "CTestModuleContainer::ChangeOperation NoMemory" ) ) );
+ }
+ }
+ else
+ {
+ // Construct heap buffer for configuration file
+ TRAP( ret, iModuleNameBuffer = HBufC::NewL( aNameBuffer.Length() ) );
+
+ if( ret == KErrNone )
+ {
+ iOperationName.Set ( iModuleNameBuffer->Des() );
+ iOperationName.Copy ( aNameBuffer );
+
+ iOperationIntBuffer = aInt;
+ iOperationType = aOperation;
+ }
+ else
+ {
+ __TRACE ( KError, ( CStifLogger::ERed, _L( "CTestModuleContainer::ChangeOperation NoMemory" ) ) );
+ }
+ }
+
+ iOperationChangeSemaphore.Signal();
+
+ return ret;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: ChangeOperationNoError
+
+ Description: Multithread safe way to change operation. This version
+ of function can't fail.
+
+ Parameters: const TOperation aOperation :in: Operation type
+ const TInt aInt :in: Operation specific int
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::ChangeOperationNoError( const TOperation aOperation,
+ const TInt aInt
+ )
+ {
+
+ iOperationChangeSemaphore.Wait();
+
+ iErrorResult = KErrNone;
+ iModuleResult = KErrNone;
+ iOperationIntBuffer = aInt;
+ iOperationType = aOperation;
+
+ iOperationChangeSemaphore.Signal();
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: Operation
+
+ Description: Multithread safe way to obtain current operation.
+
+ Parameters: None
+
+ Return Values: TBool Operation
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+//@spe const CTestModuleContainer::TOperation CTestModuleContainer::Operation()
+CTestModuleContainer::TOperation CTestModuleContainer::Operation()
+ {
+ TOperation operation;
+ iOperationChangeSemaphore.Wait();
+ operation = iOperationType;
+ iOperationChangeSemaphore.Signal();
+
+ return operation;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: ModuleResult
+
+ Description: Returns error code from test module
+
+ Parameters: None
+
+ Return Values: TInt Result code from module
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt& CTestModuleContainer::ModuleResult()
+ {
+
+ return iModuleResult;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: OperationErrorResult
+
+ Description: Returns error code from test module
+
+ Parameters: None
+
+ Return Values: TInt Result code from module
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt& CTestModuleContainer::OperationErrorResult()
+ {
+
+ return iModuleResult;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: TestModuleName
+
+ Description: Returns test module name.
+
+ Parameters: None
+
+ Return Values: const TDesC&: test module name
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+const TDesC& CTestModuleContainer::TestModuleName()
+ {
+
+ return iCTestModule->Name();
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: TestModuleName
+
+ Description: Returns test module name.
+
+ Parameters: None
+
+ Return Values: const TDesC&: test module name
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+const TDesC& CTestModuleContainer::TestModuleIniFile()
+ {
+
+ return iCTestModule->IniName();
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: ModuleResult
+
+ Description: Returns constant pointer to test case array
+
+ Parameters: None
+
+ Return Values: const RPointerArray<TTestCaseInfo>* Test cases
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+const RPointerArray<TTestCaseInfo>* CTestModuleContainer::TestCases() const
+ {
+
+ if( !iUpAndRunning )
+ {
+ return NULL;
+ }
+
+ if( iThreadContainer == NULL )
+ {
+ CTestServer::PanicServer( ENullTestThreadContainer );
+ }
+ return iThreadContainer->TestCases();
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: Complete
+
+ Description: Completes operation from any thread
+
+ Parameters: const TInt aCompletionCode :in: Completion code
+
+ Return Values: None
+
+ Errors/Exceptions: Function panics if server's thread can't be opened.
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::Complete( const TInt aCompletionCode )
+ {
+
+ TRequestStatus* req = &iStatus;
+ User::RequestComplete( req, aCompletionCode );
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: DoErrorPrint
+
+ Description: Handle error prints.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::DoErrorPrint()
+ {
+
+ iCTestModule->ErrorPrint( iErrorPrint.iPriority, iErrorPrint.iText );
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: KillTestinterferenceThread
+
+ Description: 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.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::KillTestinterferenceThread()
+ {
+ if (iCTestExecution != NULL)
+ {
+ iCTestExecution->KillTestinterferenceThread();
+ }
+ else
+ {
+ __TRACE( KError,( _L( "STIF internal error - iCTestExecution is NULL in CTestModuleContainer::KillTestinterferenceThread" ) ) );
+ User::Panic(_L("NULL pointer exception"), KErrGeneral);
+ }
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: KillTestMeasurement
+
+ Description: 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.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::KillTestMeasurement()
+ {
+ if (iCTestExecution != NULL)
+ {
+ iCTestExecution->KillTestMeasurement();
+ }
+ else
+ {
+ __TRACE( KError,( _L( "STIF internal error - iCTestExecution is NULL in CTestModuleContainer::KillTestMeasurement" ) ) );
+ User::Panic(_L("NULL pointer exception"), KErrGeneral);
+ }
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: GetRequest
+
+ Description: Return status flags.
+
+ Parameters: TRequestType aType: in: request type
+
+ Return Values: TRequestStatus*: pointer to TRequestStatus
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TRequestStatus* CTestModuleContainer::GetRequest( TRequestType aType )
+ {
+
+ TRequestStatus* status = NULL;
+
+ switch( aType )
+ {
+ case ERqTestCase:
+ status = &iStatus;
+ break;
+ case ERqErrorPrint:
+ status = &iErrorPrintHandler->iStatus;
+ break;
+ default:
+ break;
+ }
+
+ return status;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: RunL
+
+ Description: Stops active scheduler when operation in another thread
+ is completed.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::RunL()
+ {
+
+ if( iOperationType == CTestModuleContainer::EExecuteTestInThread )
+ {
+ // Make sure that any of the test interference thread's won't stay
+ // to run.
+ KillTestinterferenceThread();
+
+ // Make sure that any of the test measurement process's won't stay
+ // to run.
+ KillTestMeasurement();
+
+ if(iCTestExecution == NULL)
+ {
+ __TRACE( KError,( _L( "STIF internal error - iCTestExecution is NULL in CTestModuleContainer::RunL" ) ) );
+ User::Leave(KErrGeneral);
+ }
+ else
+ {
+ // Set the thread state
+ iCTestExecution->SetThreadState( CTestExecution::EFinished );
+
+ // If test print queue is empty, then complete request with KEof. If Queue
+ // is not empty, then do not complete. Queue will be emptied by UI.
+ iCTestExecution->CompletePrintRequestIfQueueEmpty();
+
+ // Event queue clean-up
+ iCTestExecution->CleanupEvents();
+
+ // Complete the test request
+ iCTestExecution->CompleteTestExecution( iStatus.Int() );
+
+ // Test case execution OK and test module thread's pause operation
+ // is not ongoing. Re-use old test module execution thread
+ if( iCTestExecution->TestThreadFailure() == CTestExecution::ETestThreadOk && !iIsPaused )
+ {
+ // Return this module to pool
+ __TRACE( KInit, ( _L("Freeing test module container at 0x%x"),
+ (TUint32) this ) );
+ iCTestModule->FreeTestModule( this );
+ }
+ // Problems in test case execution. Delete this test module thread and
+ // start next test case in new test module thread.
+ else
+ {
+ if( iIsPaused )
+ {
+ // Test case is paused by user and this RunL is executed also.
+ // This RunL will make Resume() operation to fail because test
+ // case is finished. Next test case cannot complete and that is
+ // why next test case will start at the "clean table".
+ __TRACE( KInit, ( _L( "Delete test module container at 0x%x because test module thread is paused while test case is finished(Cannot Resume())" ), (TUint32) this ) );
+ }
+ else
+ {
+ // delete test module thread if some thread problem has occurred
+ __TRACE( KInit, ( _L("Delete test module container at 0x%x because of thread leak (0x%x)"),
+ (TUint32) this, iCTestExecution->TestThreadFailure() ) );
+ }
+ delete this;
+ }
+ }
+ }
+ else
+ {
+ // Synchronous operation is completed, stop "nested" active scheduler.
+ //CActiveScheduler::Stop();
+ iNestedActiveScheduler->AsyncStop();
+ // Execution continues from CTestModuleContainer::WaitOperation().
+ }
+ }
+
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: DoCancel
+
+ Description: Cancel asyncronous request.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::DoCancel()
+ {
+
+ if ( iUpAndRunning == EFalse )
+ {
+
+ // Before the completion check if the status was not already completed
+ // from other thread in CTestThreadContainer::TestComplete().
+ // For details see Jira STIF-564
+ if(iStatus == KRequestPending)
+ Complete ( KErrCancel );
+
+ }
+
+ }
+
+
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: RunError
+
+ Description: Handle errors.
+
+ Because RunL does not leave, one should never come here. Just forward
+ error code and let framework panic the server in case of error.
+
+ Parameters: TInt aError: :in: Error code
+
+ Return Values: TInt Error code
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::RunError( TInt aError )
+ {
+
+ __TRACE( KError,( _L( "CTestModuleContainer::RunError %d" ), aError ) );
+
+ return aError;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: ReadParametersFromScriptFileL
+
+ Description: Read test class parameters from script file if parameter(s)
+ are/is set(TestScripter and TestCombiner).
+
+ Parameters: const TDesC& aConfig: in: Test case (config) file name.
+ TUint32& aStackSize: inout: Stack size.
+ TUint32& aHeapMinSize: inout: Heap's minimum size.
+ TUint32& aHeapMaxSize: inout: Heap's maximum size.
+
+ Return Values: Symbian error code.
+
+ Errors/Exceptions: Leaves if User::LeaveIfError() leaves
+ Leaves if User::LeaveIfNull() leaves
+
+ Status: Approved
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::ReadParametersFromScriptFileL(
+ const TDesC& aConfig,
+ TInt& aStackSize,
+ TInt& aHeapMinSize,
+ TInt& aHeapMaxSize )
+ {
+ // __UHEAP_MARK;
+
+ RFs fileServer;
+ RFile file;
+ TInt ret( KErrNone );
+
+ User::LeaveIfError( fileServer.Connect() );
+ CleanupClosePushL( fileServer );
+
+ __TRACE( KInit, ( _L( "ReadParametersFromScriptFile(): Open configfile [%S]" ), &aConfig ) );
+
+ TParse parse;
+ parse.Set( aConfig, NULL, NULL );
+
+ User::LeaveIfError( fileServer.SetSessionPath( parse.DriveAndPath() ) );
+
+ User::LeaveIfError( file.Open( fileServer, aConfig, EFileRead | EFileShareAny ) );
+ CleanupClosePushL( file );
+
+ TInt size( 0 );
+ User::LeaveIfError( file.Size( size ) );
+
+ const TInt tmpSize = KMaxName; // 128
+ TInt offset( 0 ); // Offset value to parts reading
+
+ // Indications for tags
+ TBool start_tag_found( EFalse );
+ TBool end_tag_found( EFalse );
+ // Offset values for start and end position parsing
+ TInt offset_start( 0 );
+ TInt offset_end( 0 );
+
+ /* Search is combined to section that include tags. After this create new
+ combined section that include second buffer data and new buffer data.
+ Section: 1) 1+2
+ 2) 2+1
+ 2) 1+2 etc. This should ensure that all data is search.
+ */
+
+ // Construct modifiable heap-based descriptor. tmp1 to CleanupStack
+ // This for first data buffer
+ HBufC8* tmp1 = HBufC8::NewLC( tmpSize ); // 128
+ TPtr8 buf1 = tmp1->Des();
+
+ // Construct modifiable heap-based descriptor. tmp2 to CleanupStack
+ // This for second data buffer
+ HBufC8* tmp2 = HBufC8::NewLC( tmpSize ); // 128
+ TPtr8 buf2 = tmp2->Des();
+
+ // Construct modifiable heap-based descriptor. tmp3 to CleanupStack
+ // This includes both first and second data buffers
+ HBufC* tmp3 = HBufC::NewLC( tmpSize + tmpSize ); // 256
+ TPtr currentSection = tmp3->Des();
+
+ // Construct modifiable heap-based descriptor. tmp4 to CleanupStack
+ // This is for changing 8 bit to 16 bit
+ HBufC* tmp4 = HBufC::NewLC( tmpSize ); // 128
+ TPtr to16bit = tmp4->Des();
+
+ ret = KErrNone;
+
+ // Read data to buffer 1
+ // tmp4, tmp3, tmp2 and tmp1 are in CleanupStack => Leave OK
+ // CleanupClosePushL is used to fileServer and file => Leave OK
+ User::LeaveIfError( file.Read( offset, buf1, tmpSize ) );
+
+ // For next buffer reading
+ offset += tmpSize;
+
+ // Read data to buffer 2
+ // tmp4, tmp3, tmp2 and tmp1 are in CleanupStack => Leave OK
+ // CleanupClosePushL is used to fileServer and file => Leave OK
+ User::LeaveIfError( file.Read( offset, buf2, tmpSize ) );
+
+ // 8 bit to 16. Create first combined buffer 1 and buffer 2 that
+ // is used for searching.
+ to16bit.Copy( buf1 );
+ currentSection.Copy( to16bit );
+ to16bit.Copy( buf2 );
+ currentSection.Append( to16bit );
+
+ // Check if small files to be parsed(e.g. settings + one short case).
+ TInt bigsize( 0 );
+ // Check if parsed section is smaller than 256
+ if( size < ( tmpSize + tmpSize ) )
+ {
+ bigsize = size;
+ }
+ else
+ {
+ bigsize = tmpSize + tmpSize; // 256
+ }
+
+ do
+ {
+ // Start the next buffer reading
+ offset += tmpSize;
+
+ // Search the start tag
+ ret = currentSection.Find( KStifSettingsStartTag );
+ if( ret != KErrNotFound )
+ {
+ // Succesfully search, take the start offset
+ ret = file.Seek( ESeekCurrent, offset_start );
+ if( ret == KErrNone )
+ {
+ start_tag_found = ETrue;
+ // Current section is end so offset to beging of the
+ // combined section.
+ offset_start = ( offset_start - ( bigsize ) );
+ }
+ }
+ // Search the end tag
+ ret = currentSection.Find( KStifSettingsEndTag );
+ if( ret != KErrNotFound )
+ {
+ // Succesfully search, take the end offset
+ ret = file.Seek( ESeekCurrent, offset_end );
+ if( ret == KErrNone )
+ {
+ end_tag_found = ETrue;
+ }
+ }
+
+ // Both start and end tags are founded, start parsing sizes.
+ if( start_tag_found && end_tag_found )
+ {
+ TInt length = ( offset_end - offset_start );
+
+ // Construct modifiable heap-based descriptor.
+ // setting_buf to CleanupStack
+ HBufC8* setting_buf = HBufC8::NewLC( length );// 8 bit for reading
+ TPtr8 setting8 = setting_buf->Des();
+
+ // Construct modifiable heap-based descriptor.
+ // setting_buf2 to CleanupStack
+ HBufC* setting_buf2 = HBufC::NewLC( length );// 16 bit for parsing
+ TPtr setting16 = setting_buf2->Des();
+
+ // Read data from the founded STIF settings sections
+ ret = KErrNone;
+ // HBufCs are in CleanupStack => Leave OK
+ // CleanupClosePushL is used to fileServer and file => Leave OK
+ User::LeaveIfError( file.Read( offset_start, setting8, length ) );
+
+ // Section 8 bit to 16.
+ setting16.Copy( setting8 );
+
+ // Start create parser for parsing heap and stack sizes.
+ // NOTE: Comments are parsed away from the section.
+ CStifParser* parser = NULL;
+ User::LeaveIfNull( parser = CStifParser::NewL( setting16,
+ CStifParser::ECStyleComments ) );
+ CleanupStack::PushL(parser);
+
+ CStifSectionParser* section = NULL;
+ User::LeaveIfNull( section = parser->SectionL( KStifSettingsStartTag,
+ KStifSettingsEndTag ) );
+ CleanupStack::PushL(section);
+ TInt lineRet( KErrNone );
+ TInt integer( 0 );
+
+ // Try to get stack size
+ CStifItemParser* itemLine = NULL;
+ TRAPD( parse_ret, itemLine = section->GetItemLineL(
+ KUserDefStackSize ) );
+ if ( parse_ret == KErrNone && itemLine != NULL )
+ {
+ lineRet = itemLine->GetInt( KUserDefStackSize, integer );
+ if ( lineRet == KErrNone )
+ {
+ aStackSize = integer;
+ }
+ }
+ delete itemLine;
+ itemLine = NULL;
+
+ // Try to get minimum heap size
+ TRAP( parse_ret, itemLine = section->GetItemLineL(
+ KUserDefMinHeap ) );
+ if ( parse_ret == KErrNone && itemLine != NULL )
+ {
+ lineRet = itemLine->GetInt( KUserDefMinHeap, integer );
+ if ( lineRet == KErrNone )
+ {
+ aHeapMinSize = integer;
+ }
+ }
+ delete itemLine;
+ itemLine = NULL;
+
+ // Try to get maximum heap size
+ TRAP( parse_ret, itemLine = section->GetItemLineL(
+ KUserDefMaxHeap ) );
+ if ( parse_ret == KErrNone && itemLine != NULL )
+ {
+ lineRet = itemLine->GetInt( KUserDefMaxHeap, integer );
+ if ( lineRet == KErrNone )
+ {
+ aHeapMaxSize = integer;
+ }
+ }
+ delete itemLine;
+
+ CleanupStack::Pop(section);
+ CleanupStack::Pop(parser);
+
+ CleanupStack::PopAndDestroy( setting_buf2 );
+ CleanupStack::PopAndDestroy( setting_buf );
+
+ delete section;
+ delete parser;
+
+ break; // Stop the do branch
+ }
+
+ // Start to create new section for search
+
+ // 8 bit to 16. Last buffer to first
+ to16bit.Copy( buf2 );
+ currentSection.Copy( to16bit );
+
+ // Read new data to buffer 1
+ ret = KErrNone;
+ User::LeaveIfError( file.Read( offset, buf1, tmpSize ) );
+
+ // 8 bit to 16. Append
+ to16bit.Copy( buf1 );
+ currentSection.Append( to16bit );
+
+ // Copy first buffer data to buffer 2. This is added to first
+ // in section in next run
+ buf2.Copy( buf1 );
+
+ } while( offset < size );
+
+ CleanupStack::PopAndDestroy( tmp4 );
+ CleanupStack::PopAndDestroy( tmp3 );
+ CleanupStack::PopAndDestroy( tmp2 );
+ CleanupStack::PopAndDestroy( tmp1 );
+
+ CleanupStack::PopAndDestroy( &file );
+ CleanupStack::PopAndDestroy( &fileServer );
+ file.Close();
+ fileServer.Close();
+
+ //__UHEAP_MARKEND;
+
+ return KErrNone;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: ReadParametersFromTestModule
+
+ Description: Loads dynamically testmodule and calls SetRequirements()-
+ method for test module parameter handling.
+
+ Parameters: const TDesC& aModuleName: in: Test module name
+ CTestModuleParam*& aTestModuleParam: inout: Object for handling
+ test module parameters.
+
+ Return Values: TInt: Symbian error code.
+
+ Errors/Exceptions: None.
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::ReadParametersFromTestModule(
+ const TDesC& aModuleName,
+ CTestModuleParam*& aTestModuleParam )
+ {
+ __TRACE( KInit, ( _L( "ReadParametersFromTestModule() [%S]" ), &aModuleName ) );
+ RLibrary testModule;
+ // Load the module
+ TPtrC dllName;
+
+ // Remove optional index appended to module name
+ TFileName validModuleName;
+ RemoveOptionalIndex(aModuleName, validModuleName);
+ __TRACE(KInit, (_L( "Valid module name is [%S] (extracted from [%S])"), &validModuleName, &aModuleName));
+ dllName.Set(validModuleName);
+
+ // Loading should work with and without '.dll' extension.
+ TInt r = testModule.Load( dllName );
+ if ( r != KErrNone )
+ {
+ __TRACE( KError, ( CStifLogger::EError, _L("Can't initialize test module[%S], code = %d"), &dllName, r ) );
+ return KErrNotFound;
+ }
+ else
+ {
+ // Print reset module name
+ __TRACE( KInit, ( _L("Loaded test module[%S]"), &dllName ) );
+ }
+
+
+
+ CTestInterfaceFactoryTestModule libEntry = NULL;
+
+#if defined( __ARMCC__ )
+ {
+ // In this environment the heap and stack feature may crash if
+ // test module not include a workaround for ARM RVCT(ARMv5) compiler
+ // error. For more information see STIF user guide.
+ __TRACE ( KInit, ( _L( "Workaround for ARM RVCT(ARMv5) compiler error should be included to TestModule." ) ) );
+ }
+#endif // #if defined(__ARMCC__)
+
+ // Get pointer to second exported function
+ // Verify that there is function
+ //CTestInterfaceFactoryTestModule libEntry;
+ libEntry = (CTestInterfaceFactoryTestModule) testModule.Lookup( 2 );
+ if ( libEntry == NULL )
+ {
+ // New instance can't be created
+ __TRACE( KInit, (_L( "Test module is old version and has not SetRequirements() feature." ) ) );
+ testModule.Close();
+ return KErrNotSupported;
+ }
+ else
+ {
+ __TRACE ( KInit, ( _L("Pointer to 2st exported received")));
+ }
+
+ // Calls dynamically loaded module's second method.
+ __TRACE ( KVerbose, (_L("Calling 2st exported at 0x%x"), (TUint32) libEntry ));
+ TUint32 check = 0;
+ TInt ret = (*libEntry)( aTestModuleParam, check );
+ if( check != KStifTestModuleParameterChanged )
+ {
+ // Problems in def-file definitions. Test module is old wersion
+ // and has not SetRequirements feature.
+ RDebug::Print( ( _L( "STIF TF: Test module is old version and has not SetRequirements() feature." ) ) );
+ __TRACE( KInit, (_L( "Test module is old version and has not SetRequirements() feature." ) ) );
+ testModule.Close();
+ return KErrNotSupported;
+ }
+ if( ret != KErrNone )
+ {
+ __TRACE (KInit, (_L("ReadParametersFromTestModule; SetRequirements fails with error: %d"), ret ) );
+ testModule.Close();
+ return ret;
+ }
+
+ libEntry = NULL;
+ testModule.Close(); // After close test module's pointer is not
+ // valid anymore.
+
+ return KErrNone;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: GetTestModuleParams
+
+ Description: Load test module dynamically. If loading is done succesfully
+ then set test module's parameters according to version.
+ Verify received parameters.
+
+ Parameters: const TDesC& aModuleName: in: Test module name.
+ const TDesC& aConfig: in: Test case (config) file name.
+ TInt& aStackSize: inout: Stack size.
+ TInt& aHeapMinSize: inout: Heap's minimum size.
+ TInt& aHeapMaxSize: inout: Heap's maximum size.
+
+ Return Values: TInt: Symbian error code.
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CTestModuleContainer::GetTestModuleParams( const TDesC& aModuleName,
+ const TDesC& aConfig,
+ TInt& aStackSize,
+ TInt& aHeapMinSize,
+ TInt& aHeapMaxSize )
+ {
+ TInt r( KErrNone );
+
+ // There is lower case despite what is initialization file given.
+ // Module name is without dll extension.
+ // Check is TestScripter or TestCombiner and test case (config) file
+ // name is given.
+ if( ( aModuleName.Find( KTestScripterName ) != KErrNotFound ||
+ aModuleName == _L( "testcombiner" ) ) && aConfig != KNullDesC )
+ {
+ TRAPD( ret, r = ReadParametersFromScriptFileL( aConfig, aStackSize,
+ aHeapMinSize, aHeapMaxSize ) );
+ if( r != KErrNone )
+ {
+ __TRACE( KInit, ( CStifLogger::ERed, _L( "Cannot set Test Class's stack or heap sizes, fail with error: %d" ), r ) );
+ __TRACE( KInit, ( _L( "Default sizes will be use(See KTestThreadMinHeap, KTestThreadMinHeap and KStackSize)" ) ) );
+ return r;
+ }
+ if( ret != KErrNone )
+ {
+ __TRACE( KInit, ( CStifLogger::ERed, _L( "Cannot set Test Class's stack or heap sizes, leaves with error: %d" ), r ) );
+ __TRACE( KInit, ( _L( "Default sizes will be use(See KTestThreadMinHeap, KTestThreadMinHeap and KStackSize)" ) ) );
+ return ret;
+ }
+ }
+ else
+ {
+ CTestModuleParam* testModuleParam = NULL;
+ //--PYTHON-- begin
+ if(aModuleName.Find(KPythonScripter) != KErrNotFound)
+ {
+ RDebug::Print(_L("CTestModuleContainer::GetTestModuleParams reading params for PythonScripter, aModuleName=[%S]"), &aModuleName);
+ TName n;
+ n.Copy(KPythonScripter);
+ r = ReadParametersFromTestModule( n, testModuleParam );
+ }
+ else
+ //--PYTHON-- end
+ r = ReadParametersFromTestModule( aModuleName, testModuleParam );
+
+ if( r != KErrNone )
+ {
+ __TRACE( KInit, ( _L( "Cannot set Test Module's stack or heap sizes, fails with: %d" ), r ) );
+ __TRACE( KInit, ( _L( "Default sizes will be use(See KTestThreadMinHeap, KTestThreadMinHeap and KStackSize)" ) ) );
+ delete testModuleParam;
+ return r;
+ }
+
+ if ( testModuleParam->Version() == 1 )
+ {
+ // Casting
+ CTestModuleParamVer01* paramVer01 = ( CTestModuleParamVer01* ) testModuleParam;
+ aStackSize = paramVer01->iTestThreadStackSize;
+ aHeapMinSize = paramVer01->iTestThreadMinHeap;
+ aHeapMaxSize = paramVer01->iTestThreadMaxHeap;
+ }
+
+ delete testModuleParam;
+ }
+
+ // Verify that sizes are valid. If problems are notices then use default
+ // value
+
+ // 1) "The panic occurs when the value of the stack size is negative."
+ if( aStackSize < 0 )
+ {
+ RDebug::Print( ( _L("STIF TF: GetTestModuleParams() fails because value of the stack size is negative, default value is taken into use") ) );
+ __TRACE( KInit, ( CStifLogger::ERed, _L("STIF TF: GetTestModuleParams() fails because value of the stack size is negative, default value is taken into use" ) ) );
+ // Use default value
+ aStackSize = KStackSize;
+ }
+
+ // 2) "The panic occurs if the minimum heap size specified is less
+ // than KMinHeapSize".
+ // KMinHeapSize: "Functions that require a new heap to be allocated will
+ // either panic, or will reset the required heap size to this value if a
+ // smaller heap size is specified".
+ if( aHeapMinSize < KMinHeapSize )
+ {
+ RDebug::Print( _L( "STIF TF: GetTestModuleParams() fails because test module minimum heap size is less than KMinHeapSize:[%d], default value is taken into use" ), KMinHeapSize );
+ __TRACE( KInit, ( CStifLogger::ERed, _L("STIF TF: GetTestModuleParams() fails because test module minimum heap size is less than KMinHeapSize:[%d], default value is taken into use"), KMinHeapSize ) );
+ // Use default value(Note: This is used for now on)
+ aHeapMinSize = KTestThreadMinHeap;
+ }
+
+ // 3) "The panic occurs if the minimum heap size specified is greater than
+ // the maximum size to which the heap can grow".
+ // Check this last !
+ if( aHeapMinSize > aHeapMaxSize )
+ {
+ RDebug::Print( ( _L("STIF TF: GetTestModuleParams() fails because the maximum heap size is specified less than minimum heap size, default values is taken into use" ) ) );
+ __TRACE( KInit, ( CStifLogger::ERed, _L( "STIF TF: GetTestModuleParams() fails because the maximum heap size is specified less than minimum heap size, default values is taken into use" ) ) );
+ // Use default values
+ aHeapMinSize = KTestThreadMinHeap;
+ aHeapMaxSize = KTestThreadMaxHeap;
+ }
+
+ __TRACE( KInit, ( _L( "[%S] uses:" ), &aModuleName ) );
+ __TRACE( KInit, ( _L( "Stack size: [%d]" ), aStackSize ) );
+ __TRACE( KInit, ( _L( "Minimum heap size: [%d]" ), aHeapMinSize ) );
+ __TRACE( KInit, ( _L( "Maximum heap size: [%d]" ), aHeapMaxSize ) );
+
+ return KErrNone;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: GetTestCaseTitleL
+
+ Description: Gets title of currently running test case.
+
+ Parameters: TDes& aTestCaseTitle: out: Test case title.
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CTestModuleContainer::GetTestCaseTitleL(TDes& aTestCaseTitle)
+ {
+ //currently run test case stored in the iOperationIntBuffer variable
+ iCTestModule->GetTestCaseTitleL( iOperationIntBuffer,
+ iCTestExecution->GetConfigFileName(),
+ aTestCaseTitle);
+ }
+
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CTestModuleContainer
+
+ Method: GetTestModule
+
+ Description: Gets pointer to test module
+
+ Parameters: none
+
+ Return Values: CTestModule* : Pointer to test module
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CTestModule* CTestModuleContainer::GetTestModule()
+ {
+
+ return iCTestModule;
+ }
+
+
+/*
+-------------------------------------------------------------------------------
+
+ DESCRIPTION
+
+ This module contains implementation of CPrintHandler class member functions.
+ CErrorPrintHandler listens print notifications from test thread.
+
+-------------------------------------------------------------------------------
+*/
+
+// ================= MEMBER FUNCTIONS =========================================
+
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CErrorPrintHandler
+
+ Method: NewL
+
+ Description: Constructs a new CErrorPrintHandler object.
+
+ Parameters: CTestExecution& aExecution: in: "Parent"
+
+ Return Values: CErrorPrintHandler*: New undertaker
+
+ Errors/Exceptions: Leaves if memory allocation or ConstructL leaves.
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CErrorPrintHandler* CErrorPrintHandler::NewL( CTestModuleContainer& aContainer )
+ {
+
+ CErrorPrintHandler* self = new( ELeave ) CErrorPrintHandler( aContainer );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CErrorPrintHandler
+
+ Method: ConstructL
+
+ Description: Second level constructor.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CErrorPrintHandler::ConstructL()
+ {
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CErrorPrintHandler
+
+ Method: CErrorPrintHandler
+
+ Description: Constructor
+
+ Parameters: CTestModuleContainer& aExecution :in: "Parent"
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CErrorPrintHandler::CErrorPrintHandler( CTestModuleContainer& aContainer ) :
+ CActive( CActive::EPriorityStandard ),
+ iContainer( aContainer )
+ {
+
+ CActiveScheduler::Add ( this );
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CErrorPrintHandler
+
+ Method: ~CErrorPrintHandler
+
+ Description: Destructor.
+ Cancels active request.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+CErrorPrintHandler::~CErrorPrintHandler()
+ {
+
+ Cancel();
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CErrorPrintHandler
+
+ Method: StartL
+
+ Description: Starts to monitor thread.
+
+ Parameters: None
+
+ Return Values: TInt Always KErrNone
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CErrorPrintHandler::StartL()
+ {
+
+ __TRACE( KPrint, ( _L( "CErrorPrintHandler::StartL" ) ) );
+
+ iStatus = KRequestPending;
+ SetActive();
+
+ // Signal test thread
+ iContainer.iErrorPrintSem.Signal();
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CErrorPrintHandler
+
+ Method: RunL
+
+ Description: Handles thread death.
+ Function does:
+ 1 ) Stops monitoring thread
+ 1 ) Marks thread death
+ 2 ) Completes ongoing requests
+ 3 ) Cleans the memory
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void CErrorPrintHandler::RunL()
+ {
+
+ __TRACE( KPrint, ( _L( "CErrorPrintHandler::RunL [%d]" ), iStatus.Int() ) );
+
+ iContainer.DoErrorPrint();
+
+ // enable error print request
+ iContainer.iErrorPrintHandler->StartL();
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CErrorPrintHandler
+
+ Method: DoCancel
+
+ Description: Stops print notification listening.
+
+ Parameters: None
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+
+void CErrorPrintHandler::DoCancel()
+ {
+
+ __TRACE( KPrint, ( _L( "CErrorPrintHandler::DoCancel" ) ) );
+
+ // Signal test thread
+ iContainer.iErrorPrintSem.Wait();
+
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrCancel );
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: CErrorPrintHandler
+
+ Method: RunError
+
+ Description: Handle errors. RunL function does not leave, so one should
+ never come here.
+
+ Print trace and let framework handle error( i.e to do Panic )
+
+ Parameters: TInt aError: :in: Error code
+
+ Return Values: TInt Error code
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CErrorPrintHandler::RunError( TInt aError )
+ {
+
+ __TRACE( KError,( _L( "CErrorPrintHandler::RunError" ) ) );
+
+ return aError;
+
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: -
+
+ Method: CheckModuleName
+
+ Description: Check is module TestScripter. Does parsing and returns new
+ module name and error codes(Needed operations when creating
+ server sessions to TestScripter).
+
+ Parameters: TFileName aModuleName: in: Module name for checking.
+ TFileName& aNewModuleName: inout: Parsed module name.
+
+ Return Values: KErrNone if TestScripter releated module.
+ KErrNotFound if not TestScripter releated module.
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+TInt CheckModuleName( TFileName aModuleName, TFileName& aNewModuleName )
+ {
+//--PYTHON-- old code has been replaced with the new one
+/*
+ // Check that length is greated than KTestScripterNameLength
+ if( aModuleName.Length() < KTestScripterNameLength )
+ {
+ return KErrNotFound;
+ }
+ // Check is TestScripter
+ TPtrC check( aModuleName.Mid( 0, KTestScripterNameLength ) );
+ TInt ret = check.Compare( KTestScripterName );
+ if( ret == KErrNone )
+ {
+ aNewModuleName.Copy( aModuleName.Mid( 0, KTestScripterNameLength ) );
+ }
+ else
+ {
+ return KErrNotFound;
+ }
+
+ return KErrNone;
+*/
+
+ // Check that length is greated than KTestScripterNameLength
+ if( aModuleName.Length() >= KTestScripterNameLength )
+ {
+ TPtrC check( aModuleName.Mid( 0, KTestScripterNameLength ) );
+ TInt ret = check.Compare( KTestScripterName );
+ if( ret == KErrNone )
+ {
+ aNewModuleName.Copy( aModuleName.Mid( 0, KTestScripterNameLength ) );
+ return KErrNone;
+ }
+ }
+
+ // Check that length is greated than KTestScripterNameLength
+ if( aModuleName.Length() >= KPythonScripterLength )
+ {
+ TPtrC check( aModuleName.Mid( 0, KPythonScripterLength ) );
+ TInt ret = check.Compare( KPythonScripter );
+ if( ret == KErrNone )
+ {
+ aNewModuleName.Copy( aModuleName.Mid( 0, KPythonScripterLength ) );
+ return KErrNone;
+ }
+ }
+
+ return KErrNotFound;
+ }
+
+/*
+-------------------------------------------------------------------------------
+
+ Class: -
+
+ Method: RemoveOptionalIndex
+
+ Description: Remove optional index appended to module name.
+ If it is found (@ char) then set new module name without it.
+ This feature is used when iSeparateProcesses is set in
+ TestEngine.
+
+ Parameters: TFileName aModuleName: in: Module name for checking.
+ TFileName& aNewModuleName: inout: Parsed module name.
+
+ Return Values: None
+
+ Errors/Exceptions: None
+
+ Status: Proposal
+
+-------------------------------------------------------------------------------
+*/
+void RemoveOptionalIndex(const TDesC& aModuleName, TDes& aNewModuleName)
+ {
+ //Copy module name to destination buffer
+ aNewModuleName.Copy(aModuleName);
+
+ //Search for @ char (it means that some index has been appended)
+ TInt index = aNewModuleName.Find(_L("@"));
+
+ //Remove index form name (if found)
+ if(index != KErrNotFound)
+ {
+ aNewModuleName.Delete(index, aNewModuleName.Length() - index);
+ }
+ }
+
+// End of File