1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 * 

    14 * Description: This module contains implementation of 

    15 * CTestThreadContainer class implementation. These functions are 

    16 * called from the context of the test execution thread.

    17 *

    18 */

    19 

    20 // INCLUDE FILES

    21 #include <e32std.h>

    22 #include <e32svr.h>

    23 #include <e32uid.h>

    24 #include <StifTestModule.h>

    25 #include "ThreadLogging.h"

    26 #include "TestEngineClient.h"

    27 #include <stifinternal/TestServerClient.h>

    28 #include "TestServer.h"

    29 #include "TestThreadContainer.h"

    30 #include "TestServerCommon.h"

    31 #include "TestServerModuleIf.h"

    32 #include "TestServerEvent.h"

    33 #include "TestThreadContainerRunner.h"

    34 #include <stifinternal/TestThreadContainerRunnerFactory.h>

    35 

    36 // EXTERNAL DATA STRUCTURES

    37 

    38 // EXTERNAL FUNCTION PROTOTYPES

    39 

    40 // CONSTANTS

    41 

    42 // MACROS

    43 #ifdef THREADLOGGER

    44 #undef THREADLOGGER

    45 #endif

    46 #define THREADLOGGER iThreadLogger 

    47 

    48 // LOCAL CONSTANTS AND MACROS

    49 

    50 // MODULE DATA STRUCTURES

    51 

    52 // LOCAL FUNCTION PROTOTYPES

    53 

    54 // FORWARD DECLARATIONS

    55 

    56 // ==================== LOCAL FUNCTIONS =======================================

    57 

    58 // None

    59 

    60 // ================= MEMBER FUNCTIONS =========================================

    61 

    62 /*

    63 -------------------------------------------------------------------------------

    64 

    65     Class: CTestThreadContainer

    66 

    67     Method: NewL

    68 

    69     Description: Returns new CTestThreadContainer instance.

    70 

    71     Parameters: None

    72 

    73     Return Values: CTestThreadContainer*            New instance

    74 

    75     Errors/Exceptions: Function leaves if memory allocation fails or

    76                        CTestThreadContainer ConstructL leaves.

    77 

    78     Status: Proposal

    79 

    80 -------------------------------------------------------------------------------

    81 */

    82 CTestThreadContainer* CTestThreadContainer::NewL( 

    83     CTestModuleContainer* aModuleContainer,

    84     TThreadId aServerThreadId )

    85     {

    86 

    87     CTestThreadContainer* self = 

    88         new ( ELeave ) CTestThreadContainer( aModuleContainer );

    89     CleanupStack::PushL( self );

    90     self->ConstructL( aServerThreadId );

    91     CleanupStack::Pop( self );

    92     return self;

    93 

    94     }

    95 

    96 /*

    97 -------------------------------------------------------------------------------

    98 

    99     Class: CTestThreadContainer

   100 

   101     Method: ConstructL

   102 

   103     Description: Second level constructor.

   104 

   105     Parameters: None

   106 

   107     Return Values: CTestThreadContainer*            New instance

   108 

   109     Errors/Exceptions: None

   110 

   111     Status: Proposal

   112     

   113 -------------------------------------------------------------------------------

   114 */

   115 void CTestThreadContainer::ConstructL( TThreadId aServerThreadId )

   116     {

   117     

   118     User::LeaveIfError( iServerThread.Open( aServerThreadId ) );

   119     

   120     iErrorPrintSem.SetHandle( ModuleContainer().ErrorPrintSemHandle() );

   121     User::LeaveIfError( iErrorPrintSem.Duplicate( iServerThread ) );

   122     

   123     }

   124 

   125 /*

   126 -------------------------------------------------------------------------------

   127 

   128     Class: CTestThreadContainer

   129 

   130     Method: CTestThreadContainer

   131 

   132     Description: Constructor.

   133 

   134     Parameters: None

   135 

   136     Return Values: None

   137 

   138     Errors/Exceptions: None

   139 

   140     Status: Proposal

   141     

   142 -------------------------------------------------------------------------------

   143 */

   144 CTestThreadContainer::CTestThreadContainer( 

   145     CTestModuleContainer* aModuleContainer ):

   146     iModuleContainer( aModuleContainer ),

   147     iCheckResourceFlags( 0 )

   148     {

   149    

   150     ModuleContainer().SetThreadContainer( this );

   151     

   152     StifMacroErrorInit(); // Initialization

   153 

   154     }

   155 

   156 /*

   157 -------------------------------------------------------------------------------

   158 

   159     Class: CTestThreadContainer

   160 

   161     Method: ~CTestThreadContainer

   162 

   163     Description: Destructor

   164 

   165     Parameters: None

   166 

   167     Return Values: None

   168 

   169     Errors/Exceptions: None

   170 

   171     Status: Proposal

   172 

   173 -------------------------------------------------------------------------------

   174 */

   175 CTestThreadContainer::~CTestThreadContainer()

   176     {

   177 

   178     // Close mutexes

   179     if ( iPrintMutex.Handle() != 0 ) iPrintMutex.Close();

   180     if ( iEventMutex.Handle() != 0 ) iEventMutex.Close();

   181     if ( iSndMutex.Handle() != 0 ) iSndMutex.Close();

   182     if ( iRcvMutex.Handle() != 0 ) iRcvMutex.Close();

   183     if ( iInterferenceMutex.Handle() != 0 ) iInterferenceMutex.Close();

   184     if ( iMeasurementMutex.Handle() != 0 ) iMeasurementMutex.Close();

   185     if ( iCommandMutex.Handle() != 0 ) iCommandMutex.Close();

   186 

   187     // Mutex for testcomplete and cancel operations. Close duplicate mutex

   188     if ( iTestThreadMutex.Handle() != 0 ) iTestThreadMutex.Close();

   189 

   190     // Close semaphores

   191     if ( iPrintSem.Handle() != 0 ) iPrintSem.Close();

   192     if ( iErrorPrintSem.Handle() != 0 ) iErrorPrintSem.Close();

   193     if ( iEventSem.Handle() != 0 ) iEventSem.Close();

   194     if ( iSndSem.Handle() != 0 ) iSndSem.Close();

   195     if ( iRcvSem.Handle() != 0 ) iRcvSem.Close();

   196     if ( iInterferenceSem.Handle() != 0 ) iInterferenceSem.Close();

   197     if ( iMeasurementSem.Handle() != 0 ) iMeasurementSem.Close();

   198     //if ( iReceiverSem.Handle() != 0 ) iReceiverSem.Close();

   199     if ( iCommandSem.Handle() != 0) iCommandSem.Close();

   200     

   201     iServerThread.Close();

   202     

   203     }

   204 

   205 /*

   206 -------------------------------------------------------------------------------

   207 

   208     Class: CTestThreadContainer

   209 

   210     Method: InitializeModule

   211 

   212     Description: Initialize test module.

   213 

   214     Function obtains pointer to the first exported function of the test module,

   215     and calls that function to obtain an instance of CTestModuleBase derived

   216     object. After that the "Init()"-method is called. If some operation fails,

   217     module will be deleted and error code is returned.

   218 

   219     This function is a static member function, which is intented to be called

   220     from the context of the test module thread.

   221 

   222     Parameters: RLibrary& aModule                 :in: Module to be loaded

   223     

   224     Return Values: TInt                                Error code from module

   225                                                        or memory allocation.

   226 

   227     Errors/Exceptions: None.

   228 

   229     Status: Proposal

   230 

   231 -------------------------------------------------------------------------------

   232 */

   233 TInt CTestThreadContainer::InitializeModuleInThread ( RLibrary& aModule )

   234     {        

   235         

   236     __TRACEI ( KInit, ( _L("Starting test module initialization") ) );

   237     __TRACEI ( KInit, ( CStifLogger::EBold,  _L("Module name \"%S\""), 

   238         &ModuleContainer().OperationName() ) );

   239     ModuleContainer().OperationText() = _L("E32DLL");

   240 

   241     TFileName moduleName;

   242     TFileName tmpBuffer;

   243 

   244     TInt r( KErrNone );

   245     TFileName newNameBuffer;

   246     TInt check = CheckModuleName( ModuleContainer().OperationName(), newNameBuffer );

   247     if( check == KErrNone )

   248         {

   249         // Load the module(TestScripter)

   250         r = aModule.Load( newNameBuffer );

   251         }

   252     else

   253         {

   254         // Load the module(Others)

   255         RemoveOptionalIndex(ModuleContainer().OperationName(), newNameBuffer);

   256         __TRACEI(KInit, (_L( "Valid module name is [%S] (extracted from [%S])"), &newNameBuffer, &ModuleContainer().OperationName()));

   257         r = aModule.Load(newNameBuffer);

   258         }

   259     

   260     if ( r != KErrNone )

   261         {

   262         __TRACEI (KError, ( CStifLogger::EError, _L("Can't initialize test module code = %d"), r));

   263 

   264         // Set error codes

   265         ModuleContainer().OperationErrorResult() = r;

   266         return r;

   267         }

   268     else

   269         {

   270         // Print module name

   271         moduleName = aModule.FileName();    

   272         __TRACEI (KInit, (  _L("Loaded test module[%S]"), &moduleName ) );

   273         }

   274 

   275     

   276     // Get pointer to first exported function

   277     ModuleContainer().OperationText() = _L("1st EXPORTED function");

   278     CTestInterfaceFactory libEntry;

   279     libEntry = (CTestInterfaceFactory) aModule.Lookup(1);

   280     if ( libEntry == NULL )

   281         {

   282         // New instance can't be created

   283         __TRACEI (KError, ( CStifLogger::EError, _L("Can't initialize test module, NULL libEntry")));

   284 

   285         // Set error codes

   286         ModuleContainer().OperationErrorResult() = KErrNoMemory;

   287         return KErrNoMemory;

   288         }

   289     else

   290         {

   291         __TRACEI ( KInit, ( _L("Pointer to 1st exported received")));

   292         }

   293 

   294     // initialize test module

   295     __TRACEI ( KVerbose, (_L("Calling 1st exported at 0x%x"), (TUint32) libEntry ));

   296     TRAPD ( err, iTestModule =  (*libEntry)() );

   297 

   298      // Handle leave from test module

   299     if ( err != KErrNone )

   300         {

   301         __TRACEI (KError, ( CStifLogger::EError, _L("Leave when calling 1st exported function, code %d"), err));

   302         tmpBuffer = _L("Leave from test module 1st EXPORTED function");        

   303         ErrorPrint( 1, tmpBuffer );        

   304         delete iTestModule;

   305         iTestModule = NULL;

   306 

   307         // Set error codes

   308         ModuleContainer().OperationErrorResult() = err;

   309         return err;

   310         }

   311     else if ( iTestModule == NULL )     // Handle NULL from test module init

   312         {

   313         __TRACEI (KError, ( CStifLogger::EError, _L("NULL pointer received when constructing test module")));

   314         tmpBuffer = _L("Test module 1st EXPORTED function returned NULL");        

   315         ErrorPrint( 1, tmpBuffer );        

   316         delete iTestModule;

   317         iTestModule = NULL;

   318 

   319         // Set error codes

   320         ModuleContainer().OperationErrorResult() = KErrNoMemory;

   321         return KErrNoMemory;

   322         }

   323     else

   324         {

   325         __TRACEI (KInit, (_L("Entrypoint successfully called, test module instance at 0x%x"), (TUint32)iTestModule ) );

   326         }

   327 

   328     // Verify version number.

   329     ModuleContainer().OperationText() = _L("Version");

   330     TVersion moduleAPIVersion(0,0,0);

   331     TVersion myOldAPIVersion( KOldTestModuleAPIMajor, KOldTestModuleAPIMinor, KOldTestModuleAPIBuild );

   332     TVersion myAPIVersion( KTestModuleAPIMajor, KTestModuleAPIMinor, KTestModuleAPIBuild );

   333     TRAP ( err,  moduleAPIVersion = iTestModule->Version() );

   334 

   335     if ( err != KErrNone ||  (( myOldAPIVersion.iMajor !=  moduleAPIVersion.iMajor ||

   336                                 myOldAPIVersion.iMinor !=  moduleAPIVersion.iMinor  )

   337                                 &&

   338                               ( myAPIVersion.iMajor != moduleAPIVersion.iMajor ||

   339                               	myAPIVersion.iMinor != moduleAPIVersion.iMinor ))

   340         )

   341         {

   342         tmpBuffer = moduleAPIVersion.Name();

   343         __TRACEI (KError, ( CStifLogger::EError, _L("Incorrect test module version. Module version %S"), &tmpBuffer ) );        

   344         tmpBuffer = myOldAPIVersion.Name();

   345         __TRACEI (KError, ( CStifLogger::EError, _L("Required version %S"), &tmpBuffer  ) );

   346                 

   347         tmpBuffer.Format(_L("Invalid version in [%S]"), &moduleName );

   348         ErrorPrint( 1, tmpBuffer );        

   349 

   350          // Set error codes

   351         ModuleContainer().OperationErrorResult() = KErrNotSupported;

   352         return KErrNotSupported;

   353         }

   354 

   355     ModuleContainer().OperationText() = _L("InitL");

   356     // Initialize test module

   357     TInt initResult = KErrNone;

   358     TRAP ( err, 

   359         CTestModuleIf::NewL( NULL, iTestModule );

   360         TFileName tmp = ModuleContainer().TestModuleIniFile();

   361         initResult = iTestModule->InitL( tmp, ModuleContainer().OperationIntBuffer() );

   362     );

   363 

   364     // Handle leave from test module

   365     if ( err != KErrNone )

   366         {

   367         __TRACEI (KError, ( CStifLogger::EError, _L("Leave when initializing test module code %d"), err));

   368         tmpBuffer = _L("Leave from test module InitL");        

   369         ErrorPrint( 1, tmpBuffer );   

   370         ModuleContainer().OperationText() = _L("DESTRUCTOR");

   371         delete iTestModule;

   372         iTestModule = NULL;

   373         ModuleContainer().OperationText() = _L("");

   374 

   375         // Set error codes

   376         ModuleContainer().OperationErrorResult() = err;

   377         return err;

   378         }      

   379     else if ( initResult != KErrNone ) 

   380         {     // Handle failed initialisation of test module

   381         __TRACEI (KError, ( CStifLogger::EError, _L("Can't initialize test module, code %d"), initResult));

   382         ModuleContainer().OperationText() = _L("DESTRUCTOR");

   383         delete iTestModule;

   384         iTestModule = NULL;

   385         ModuleContainer().OperationText() = _L("");

   386         

   387         // Set error code

   388         ModuleContainer().ModuleResult() = initResult;

   389         return initResult;

   390         }

   391     ModuleContainer().OperationText() = _L("");

   392 

   393     __TRACEI (KInit, ( CStifLogger::EBold, _L("Test module initialization done")));     

   394 

   395     return KErrNone;

   396 

   397     }

   398 

   399 /*

   400 -------------------------------------------------------------------------------

   401 

   402     Class: CTestThreadContainer

   403 

   404     Method: EnumerateInThread

   405 

   406     Description: Enumerate test cases. Function calls GetTestCases method

   407     from the test module.

   408 

   409     This function is a static member function, which is intented to be called

   410     from the context of the test module thread.

   411         

   412     Parameters: None

   413     

   414     Return Values: TInt                           Error code.

   415 

   416     Errors/Exceptions: None

   417 

   418     Status: Proposal

   419 

   420 -------------------------------------------------------------------------------

   421 */

   422 TInt CTestThreadContainer::EnumerateInThread()

   423     {

   424 

   425     TInt err = KErrNone;

   426     __TRACEI ( KInit, ( CStifLogger::EBold, _L("Calling GetTestCasesL") ) );

   427 

   428     if ( iCases == NULL )

   429         {

   430         iCases = new RPointerArray<TTestCaseInfo>;

   431         if ( iCases == NULL )

   432             {

   433             ModuleContainer().OperationErrorResult() = KErrNoMemory;

   434             __TRACEI ( KError, ( _L("Can't create pointer array for cases") ) );

   435             return ModuleContainer().OperationErrorResult();

   436             }

   437         }

   438 

   439     // Thread ID logging(For error situations) !!!!! ----------

   440     /*

   441     RThread t;

   442     RDebug::Print(_L("XXXXXXXXXXXXXXXXXXXXXX CurrentThread=[%d]"), t.Id() );

   443     t.Open( t.Id() );   

   444     RDebug::Print(_L("XXXXXXXXXXXXXXXXXXXXXX Real id=[%d]"), t.Id() );

   445     t.Close();

   446     */

   447     // --------------------------------------------------------

   448 

   449     ModuleContainer().OperationText() = _L("GetTestCasesL");

   450     TRAPD (r, err = iTestModule->GetTestCasesL( 

   451                         ModuleContainer().OperationName(),

   452                         *iCases ) );

   453     ModuleContainer().OperationText() = _L("");

   454 

   455     // Leave

   456     if ( r != KErrNone )

   457         {

   458         __TRACEI ( KError, ( CStifLogger::ERed, _L("GetTestCasesL leave code %d"), r ) );

   459         TName tmpBuffer = _L("Leave from test module GetTestCasesL");        

   460         ErrorPrint( 1, tmpBuffer );        

   461         FreeEnumerationDataInThread();

   462 

   463         ModuleContainer().OperationErrorResult() = r;

   464         return r;

   465         }

   466         

   467     // Error originating from test module

   468     if ( err != KErrNone )

   469         {

   470         __TRACEI ( KError, ( CStifLogger::ERed, _L("GetTestCasesL returned error %d"), err ) );

   471         FreeEnumerationDataInThread();

   472 

   473         ModuleContainer().ModuleResult() = err;

   474         return err;

   475         }

   476 

   477     __TRACEI ( KInit, ( _L("GetTestCasesL successfully called") ) );

   478 

   479     // All ok.

   480     return KErrNone;

   481 

   482     }

   483 

   484 /*

   485 -------------------------------------------------------------------------------

   486 

   487     Class: CTestThreadContainer

   488 

   489     Method: FreeEnumerationDataInThread

   490 

   491     Description: Frees the enumeration data. This function is called, when

   492     the enumeration data is read from execution thread heap to server thread

   493     heap. If cases have not been enumerated function does nothing.

   494     

   495     Function is intented to be called from the context of the test module thread.

   496 

   497     Parameters: None

   498 

   499     Return Values: None

   500 

   501     Errors/Exceptions: None

   502 

   503     Status: Proposal

   504 

   505 -------------------------------------------------------------------------------

   506 */

   507 void CTestThreadContainer::FreeEnumerationDataInThread()

   508     {

   509 

   510     __TRACEI ( KInit, ( _L("Freeing test case array") ) );

   511 

   512     if ( iCases )

   513         {

   514         iCases->ResetAndDestroy();

   515         delete iCases;

   516         iCases = NULL;

   517         }

   518     

   519     __TRACEI ( KInit, ( _L("Freeing test case array done") ) );

   520 

   521     }

   522 

   523 /*

   524 -------------------------------------------------------------------------------

   525 

   526     Class: CTestThreadContainer

   527 

   528     Method: ExecuteTestCaseInThread

   529 

   530     Description: Execute test case. This function calls either RunTestCase or 

   531     ExecuteOOMTestCase to execute and report the results.

   532 

   533     This function is a static member function, which is intented to be called

   534     from the context of the test module thread.

   535 

   536     Parameters: None

   537 

   538     Return Values: TInt: Error code

   539 

   540     Errors/Exceptions: None

   541 

   542     Status: Approved

   543 

   544 -------------------------------------------------------------------------------

   545 */

   546 TInt CTestThreadContainer::ExecuteTestCaseInThread()

   547     {        

   548     TVersion moduleAPIVersion;

   549     moduleAPIVersion = iTestModule->Version(); 

   550 

   551     __TRACEI ( KInit, 

   552         ( CStifLogger::EBold, _L("Executing test case file=[%S] case=%d"), 

   553             &ModuleContainer().OperationName(), 

   554             ModuleContainer().OperationIntBuffer() ) );

   555 

   556     TInt r = KErrNone;

   557     

   558     // Thread handle

   559     RThread thisRt;

   560     r = DuplicateMutexHandles( thisRt );

   561        

   562     // Result from RunTestCase       

   563     TTestResult caseResult; 

   564     

   565     // Execution result from RunTestCase

   566     TInt err = KErrNone;

   567 

   568     // Fill in initial values

   569     TestExecution().FullResult().iCaseExecutionResultType = 

   570         TFullTestResult::ECaseExecuted;

   571     TestExecution().FullResult().iCaseExecutionResultCode = KErrNone;            

   572     TestExecution().FullResult().iStartTime.HomeTime();

   573     TestExecution().TestThreadFailure() = CTestExecution::ETestThreadOk;

   574 

   575     // Set handle to test execution

   576     TRAP( r, CTestModuleIf::NewL( this,

   577                                   iTestModule ) );

   578 

   579     ModuleContainer().OperationText() =_L("RunTestCaseL");

   580     

   581     // Do resource checks before starting test case

   582     iCheckResourceFlags = 0;        

   583     

   584     TInt tmp;

   585     TInt threadHandleCountBeforeTest;

   586 

   587     // Request count check

   588     TInt requestCountBeforeTest = thisRt.RequestCount();

   589     // Handle count check, not checking process handles

   590     thisRt.HandleCount( tmp, threadHandleCountBeforeTest );

   591 

   592     // If handle ok, then execute test          

   593     if( r == KErrNone )

   594         {       

   595         TInt testCaseNumber = ModuleContainer().OperationIntBuffer();

   596 

   597         // Do the test

   598         __TRACEI ( KInit, ( _L("About to call RunTestCaseL. If nothing in log \

   599             after line \"Calling RunTestCaseL\", check testserver log file.") ) );        

   600                     

   601         TInt firstMemFailure = 0; 

   602         TInt lastMemFailure = 0;        

   603         // Store the OOM test type

   604         CTestModuleBase::TOOMFailureType failureType;

   605                 

   606         // Check if the current test case is supposed to be run using OOM

   607         if( iTestModule->OOMTestQueryL( ModuleContainer().OperationName(), 

   608                                         testCaseNumber, 

   609                                         failureType,

   610                                         firstMemFailure, 

   611                                         lastMemFailure ) )

   612             {

   613             //  Run the test case in OOM conditions      

   614             r = ExecuteOOMTestCase( testCaseNumber, 

   615                                     firstMemFailure, 

   616                                     lastMemFailure, 

   617                                     err, 

   618                                     caseResult );

   619             }

   620         else

   621             {

   622             // Run the test case the old way, without OOM testing           

   623             __TRACEI ( KInit, ( _L("Calling RunTestCaseL - \

   624                 OOM condition is not set") ) );

   625             TRAP( r, err = iTestModule->RunTestCaseL( 

   626                                             testCaseNumber,

   627                                             ModuleContainer().OperationName(),

   628                                             caseResult ) );

   629             }

   630         }        

   631      

   632     // Do resource checks after test case execution

   633     // Handle count check

   634     TInt threadHandleCountAfterTest;

   635     thisRt.HandleCount( tmp, threadHandleCountAfterTest );

   636     // Request count check

   637     TInt requestCountAfterTest = thisRt.RequestCount();           

   638           

   639     ModuleContainer().OperationText() =_L("");

   640 

   641     // Store end time

   642     TestExecution().FullResult().iEndTime.HomeTime();   

   643     // Remove handle to testexecution 

   644     TRAPD( rr, CTestModuleIf::NewL( NULL, iTestModule ) );

   645     

   646 

   647     if ( rr != KErrNone )

   648         {        

   649         __TRACEI ( KError, ( _L("Memory low in executionthread.") ) );        

   650         // Do not actually handle error

   651         }

   652   

   653     // Report test result. Parts of this will be overwritten if error

   654     // is detected

   655     TestExecution().FullResult().iTestResult = caseResult;

   656 

   657     // Get target exit reasons

   658     CTestModuleIf::TExitReason allowedExitReason;

   659     TInt allowedExitCode = KErrNone;

   660     ExitReason( allowedExitReason, allowedExitCode );

   661     

   662     TBool returnLeakCheckFail = EFalse;

   663 

   664     // Check are STIF macros used

   665     if( iTestMacroInfo.iIndication ) 

   666         {

   667         // STIF macros are used. Set description info, test case to

   668         // ECaseExecuted state and case execution result code to KErrNone

   669         // to get test case to failed category.

   670         TName tmpResultDes;

   671         __TRACEI ( KError, ( CStifLogger::ERed, _L("Leave from RunTestCaseL(STIF TF's macro is used)" ) ) );

   672         // Set result description

   673         tmpResultDes.Copy( _L( "FILE[") );

   674         tmpResultDes.Append( iTestMacroInfo.iFileDes );

   675         tmpResultDes.Append( _L( "] FUNCTION[" ) );

   676         tmpResultDes.Append( iTestMacroInfo.iFunctionDes );

   677         tmpResultDes.Append( _L( "] LINE[" ) );

   678         tmpResultDes.AppendNum( iTestMacroInfo.iLine );

   679         tmpResultDes.Append( _L( "]" ) );

   680         // Other result information

   681         TestExecution().FullResult().iTestResult.iResult =

   682                                             iTestMacroInfo.iReceivedError;

   683         TestExecution().FullResult().iTestResult.iResultDes = tmpResultDes;

   684         TestExecution().FullResult().iCaseExecutionResultType = 

   685                                             TFullTestResult::ECaseExecuted;

   686         // Set category to failed cases

   687         TestExecution().FullResult().iCaseExecutionResultCode = KErrNone;

   688         StifMacroErrorInit(); // Initialization back to default

   689         }

   690     else if( r != KErrNone )

   691         {   // Case has left, overwrite normal result description string

   692         __TRACEI ( KError, ( CStifLogger::ERed, _L("Leave from RunTestCaseL, code %d"), r ) );

   693         // Set result description

   694         TName tmpResultDes = _L("Leave during case:");

   695         // Check if there was already some description passed to result object

   696         if(caseResult.iResultDes.Length() > 0)

   697             {

   698             tmpResultDes.Format(_L("Leave during case [%S]:"), &caseResult.iResultDes);

   699             if(tmpResultDes.Length() > KStifMaxResultDes)

   700                 {

   701                 tmpResultDes.SetLength(KStifMaxResultDes);

   702                 }

   703             }

   704         // Other result information

   705         TestExecution().FullResult().iTestResult.iResult = KErrGeneral;

   706         TestExecution().FullResult().iTestResult.iResultDes = tmpResultDes;

   707         TestExecution().FullResult().iCaseExecutionResultType = 

   708             TFullTestResult::ECaseLeave;

   709         TestExecution().FullResult().iCaseExecutionResultCode = r;

   710         }    

   711     else if ( err != KErrNone )

   712         {   

   713         // Case has returned error (e.g. case not found )       

   714         __TRACEI ( KError, ( CStifLogger::ERed, _L("RunTestCaseL returned error %d"), err ) ); 

   715         TestExecution().FullResult().iCaseExecutionResultType = 

   716             TFullTestResult::ECaseErrorFromModule;

   717         TestExecution().FullResult().iCaseExecutionResultCode = err;

   718         }

   719     else if ( allowedExitReason != CTestModuleIf::ENormal )

   720         {

   721         // Test is failed, because it should end to panic or exception.

   722         __TRACEI ( KInit, ( _L("Case ended normally even if it should end to panic/exception") ) ); 

   723         TestExecution().FullResult().iTestResult.iResult = KErrGeneral;

   724         TestExecution().FullResult().iTestResult.iResultDes = 

   725             _L("Case did not ended to panic/exception");

   726         }

   727     // If test case is passed, check memory leak, handles etc...    

   728     else if( caseResult.iResult == KErrNone )

   729         {

   730         returnLeakCheckFail = ETrue;

   731         }

   732    

   733    // Test case leak checks

   734     // In EKA2 heap size cannot be measured because THeapWalk is no longer supported    

   735     LeakChecksForTestCase( returnLeakCheckFail, 

   736                            threadHandleCountBeforeTest,

   737                            threadHandleCountAfterTest,

   738                            requestCountBeforeTest,

   739                            requestCountAfterTest );

   740 

   741     // Close execution specific handles

   742 

   743     iPrintMutex.Close();

   744     iEventMutex.Close();

   745     iSndMutex.Close();

   746     iRcvMutex.Close();

   747     iInterferenceMutex.Close();

   748     iMeasurementMutex.Close();

   749     iCommandMutex.Close();

   750     

   751     // The Wait operation is performed to let the message from TestServer 

   752     // to TestEngine achieve TestEngine or TestCombiner.   

   753     iCommandSem.Wait();

   754     

   755     // Note: iTestThreadMutex.iClose() mutex will be used later, close in destructor.

   756     

   757     iPrintSem.Close();

   758     iEventSem.Close();

   759     iSndSem.Close();

   760     iRcvSem.Close();

   761     iInterferenceSem.Close();

   762     iMeasurementSem.Close();

   763     iCommandSem.Close();

   764 

   765     // Close thread handle 

   766     thisRt.Close();

   767 

   768     __TRACEI ( KVerbose, ( _L("ExecuteTestCase out") ) );

   769 

   770     // continues from CTestModuleContainer::RunL

   771         

   772     return KErrNone;

   773     }

   774 

   775 /*

   776 -------------------------------------------------------------------------------

   777 

   778     Class: CTestThreadContainer

   779 

   780     Method: DuplicateMutexHandles

   781 

   782     Description: Duplicates mutex handles

   783 

   784     Parameters: None

   785 

   786     Return Values: TInt

   787 

   788     Errors/Exceptions: Panic if duplication fails

   789 

   790     Status: Approved

   791 

   792 -------------------------------------------------------------------------------

   793 */

   794 TInt CTestThreadContainer::DuplicateMutexHandles( RThread& aThread )

   795     {

   796     // For duplicating mutexes

   797     iPrintMutex.SetHandle( TestExecution().PrintMutexHandle() );

   798     iEventMutex.SetHandle( TestExecution().EventMutexHandle() );

   799     iSndMutex.SetHandle( TestExecution().SndMutexHandle() );

   800     iRcvMutex.SetHandle( TestExecution().RcvMutexHandle() );

   801     iInterferenceMutex.SetHandle( TestExecution().InterferenceMutexHandle() );

   802     iMeasurementMutex.SetHandle( TestExecution().MeasurementMutexHandle() );

   803     iCommandMutex.SetHandle(TestExecution().CommandMutexHandle());

   804 

   805     // Mutex for testcomplete and cancel operations. For duplicating mutex

   806     iTestThreadMutex.SetHandle( TestExecution().TestThreadMutexHandle() );

   807 

   808     // For duplicating semaphores

   809     iPrintSem.SetHandle( TestExecution().PrintSemHandle() );

   810     iEventSem.SetHandle( TestExecution().EventSemHandle() );

   811     iSndSem.SetHandle( TestExecution().SndSemHandle() );

   812     iRcvSem.SetHandle( TestExecution().RcvSemHandle() );

   813     iInterferenceSem.SetHandle( TestExecution().InterferenceSemHandle() );

   814     iMeasurementSem.SetHandle( TestExecution().MeasurementSemHandle() );

   815     iCommandSem.SetHandle(TestExecution().CommandSemHandle());

   816     

   817     // Store thread id for later use

   818     TestExecution().SetTestThread( aThread.Id() );

   819     

   820     // Duplicate handles from server thread

   821     TRAPD( r,

   822         User::LeaveIfError( iPrintMutex.Duplicate( iServerThread ) );

   823         User::LeaveIfError( iEventMutex.Duplicate( iServerThread ) );

   824         User::LeaveIfError( iSndMutex.Duplicate( iServerThread ) );

   825         User::LeaveIfError( iRcvMutex.Duplicate( iServerThread ) );

   826         User::LeaveIfError( iInterferenceMutex.Duplicate( iServerThread ) );

   827         User::LeaveIfError( iMeasurementMutex.Duplicate( iServerThread ) );

   828         User::LeaveIfError( iCommandMutex.Duplicate( iServerThread ) );

   829         

   830         User::LeaveIfError( iTestThreadMutex.Duplicate( iServerThread ) );

   831 

   832         User::LeaveIfError( iPrintSem.Duplicate( iServerThread ) );

   833         User::LeaveIfError( iEventSem.Duplicate( iServerThread ) );

   834         User::LeaveIfError( iSndSem.Duplicate( iServerThread ) );

   835         User::LeaveIfError( iRcvSem.Duplicate( iServerThread ) );

   836         User::LeaveIfError( iInterferenceSem.Duplicate( iServerThread ) );

   837         User::LeaveIfError( iMeasurementSem.Duplicate( iServerThread ) );

   838         User::LeaveIfError( iCommandSem.Duplicate( iServerThread ) );

   839         );

   840 

   841     // Raise panic if duplications failed        

   842     if( r != KErrNone )

   843         {

   844         Panic( EDuplicateFail );

   845         }

   846     

   847     // Return the result, no error occurred

   848     return KErrNone;            

   849     }

   850 

   851 /*

   852 -------------------------------------------------------------------------------

   853 

   854     Class: CTestThreadContainer

   855 

   856     Method: ExecuteOOMTestCase

   857 

   858     Description: Executes OOM test case

   859 

   860     Parameters: None

   861 

   862     Return Values: TInt

   863 

   864     Errors/Exceptions: Panic if EOOMDisableLeakChecks is not set and test case

   865     leaks memory.                       

   866 

   867     Status: Approved

   868 

   869 -------------------------------------------------------------------------------

   870 */

   871 TInt CTestThreadContainer::ExecuteOOMTestCase( TInt aTestCaseNumber,

   872                                                TInt aFirst, 

   873                                                TInt aLast, 

   874                                                TInt& aResult, 

   875                                                TTestResult& caseResult )

   876     {

   877     TBool OOMwarning = EFalse;  

   878     __TRACEI ( KInit, ( _L("CTestThreadContainer::ExecuteOOMTestCase") ) );            

   879     __TRACEI ( KInit, ( _L("Executing test case #%d using OOM"), aTestCaseNumber ) );               

   880     

   881     // OOM test environment initialization

   882     TRAPD( r, iTestModule->OOMTestInitializeL( 

   883                                 ModuleContainer().OperationName(),

   884                                 aTestCaseNumber ); );               

   885     

   886     for( TInt i=aFirst; i<aLast; i++ )

   887         {   

   888         // Fail the i:nth heap allocation

   889         User::__DbgSetAllocFail( RHeap::EUser, RHeap::EFailNext, i  );

   890         

   891         //__TRACEI ( KInit, ( _L("Setting %d:nth heap allocation to fail"), i  ) );             

   892                 

   893         // Intersection of iCheckResourceFlags and 

   894         // EDisableMemoryLeakChecksInOOM to check if memory leak checks are to 

   895         // be used with OOM testing.        

   896         if( !( iCheckResourceFlags & CTestModuleIf::EOOMDisableLeakChecks ) )

   897             {

   898             User::__DbgMarkStart( RHeap::EUser );

   899             }

   900             

   901         TRAP( r, aResult = iTestModule->RunTestCaseL( 

   902                         aTestCaseNumber,

   903                         ModuleContainer().OperationName(),

   904                         caseResult ) );

   905         

   906         // Raise panic if test case leaks memory and EOOMDisableLeakChecks is not

   907         // set        

   908         if( !( iCheckResourceFlags & CTestModuleIf::EOOMDisableLeakChecks ) )

   909             {

   910             User::__DbgMarkEnd( RHeap::EUser, 0 );

   911             }

   912         

   913         // If no error occurred, fake a memory error to make sure that this is

   914         // the last test. If this last allocation goes wrong, it proves that 

   915         // either the FAILNEXT() macro has reached its limit or that somewhere

   916         // in the code some object TRAPped the OOM exception and did not leave.     

   917         if( ( r != KErrNoMemory ) && ( aResult != KErrNoMemory  )

   918             && ( caseResult.iResult != KErrNoMemory ) )

   919             {

   920             TInt* dummy = new TInt;

   921             OOMwarning = ( dummy != NULL );

   922             delete dummy;

   923             }

   924 

   925         // Cancel the simulated heap allocation failure

   926         User::__DbgSetAllocFail( RHeap::EUser, RHeap::ENone, 1 );

   927     

   928         if( ( r != KErrNoMemory ) && !OOMwarning && ( aResult != KErrNoMemory )

   929             && ( caseResult.iResult != KErrNoMemory ) )

   930             {

   931             // If we get here test was executed properly (= no memory error

   932             // and no warning)

   933             break;

   934             }

   935 

   936         if( OOMwarning )

   937             {            

   938             // It is possible that during testing some components TRAP the OOM

   939             // exception and continue to run (do not leave) or they return an 

   940             // error other than KErrNoMemory. These situations are making the

   941             // OOM testing really difficult, so they should be detected and 

   942             // make the tester aware.

   943              

   944             // Since each test case might have a specific oppinion on handling

   945             // this situation, it is left up to the tester to handle it by 

   946             // implementing the OOMHandleWarningL method. STIF will log a

   947             // warning and call OOMHandleWarningL method.

   948 

   949             // Print the OOM error message

   950             __TRACEI ( KInit, ( _L("Possible trapped or non-leaving allocation in test case #%d"), i  ) );                          

   951 

   952             iTestModule->OOMHandleWarningL( ModuleContainer().OperationName(), aTestCaseNumber, i );

   953 

   954             // Clear the warning flag

   955             OOMwarning = EFalse;

   956             }

   957         }

   958         

   959     // OOM test environment finalization                    

   960     __TRACEI ( KInit, ( _L("Calling OOMTestFinalizeL") ) ); 

   961     TRAPD( fres, iTestModule->OOMTestFinalizeL( 

   962                                     ModuleContainer().OperationName(), 

   963                                     aTestCaseNumber ); );

   964     // Check the result

   965     if( fres != KErrNone )

   966         {

   967         __TRACEI ( KInit, ( _L("OOMTestFinalizeL execution failed with error %d"), fres ) );                            

   968         }

   969                 

   970     return r;

   971     }

   972 

   973 /*

   974 -------------------------------------------------------------------------------

   975 

   976     Class: CTestThreadContainer

   977 

   978     Method: LeakChecksForTestCase

   979 

   980     Description: Checks test case for memory, handle and request leaks

   981 

   982     Parameters: None    

   983 

   984     Return Values: None

   985 

   986     Errors/Exceptions: None

   987 

   988     Status: Proposal

   989 

   990 -------------------------------------------------------------------------------

   991 */

   992 void CTestThreadContainer::LeakChecksForTestCase( TBool aReturnLeakCheckFail,

   993                                                   TInt aThreadHandleCountBeforeTest,

   994                                                   TInt aThreadHandleCountAfterTest,

   995                                                   TInt aRequestCountBeforeTest, 

   996                                                   TInt aRequestCountAfterTest )

   997                                                 

   998     {      

   999     __TRACEI ( KInit, ( _L("CTestThreadContainer::LeakChecksForTestCase") ) );                          

  1000 

  1001     // Note: Request leaks detection is disabled in UI components testing

  1002     if( !( iCheckResourceFlags & CTestModuleIf::ETestLeaksRequests ) && 

  1003              ( aRequestCountBeforeTest != aRequestCountAfterTest ) &&

  1004              ( !iModuleContainer->GetTestModule()->GetTestServer()->UiTesting()))

  1005         {

  1006         // Test is failed, because it should end to panic or exception.

  1007         __TRACEI ( KError, ( CStifLogger::ERed, 

  1008             _L("Asynchronous request leak from test module. Request count before:[%d] and after:[%d] test."),

  1009             aRequestCountBeforeTest, aRequestCountAfterTest ) );

  1010             

  1011         // Set failure status    

  1012         TestExecution().TestThreadFailure() |= CTestExecution::ETestRequestLeak;

  1013         if( aReturnLeakCheckFail )

  1014             {

  1015             aReturnLeakCheckFail = EFalse;   // return first fail   

  1016 #ifndef STIF_DISABLE_LEAK_CHECK 

  1017             // Testcase set to failed when request leak occurred

  1018             TestExecution().FullResult().iTestResult.iResult = KErrGeneral;

  1019 #endif

  1020             TestExecution().FullResult().iTestResult.iResultDes = 

  1021                 _L("Asynchronous request leak from testmodule");

  1022             TestExecution().FullResult().iTestResult.iResultDes.

  1023                 AppendNum( aRequestCountAfterTest );

  1024             }

  1025         }

  1026     // Note: Handle leaks detection is disabled in UI components testing

  1027     if( !( iCheckResourceFlags & CTestModuleIf::ETestLeaksHandles ) && 

  1028              ( aThreadHandleCountBeforeTest != aThreadHandleCountAfterTest ) &&

  1029              ( !iModuleContainer->GetTestModule()->GetTestServer()->UiTesting()) )

  1030         {

  1031         // Test is failed, because it should end to panic or exception.

  1032         __TRACEI ( KError, ( CStifLogger::ERed, 

  1033             _L("Thread handle leak from test module. Handle count before:[%d] and after:[%d] test."),

  1034             aThreadHandleCountBeforeTest, aThreadHandleCountAfterTest ) ); 

  1035             

  1036         // Set failure status

  1037         TestExecution().TestThreadFailure() |= CTestExecution::ETestHandleLeak;    

  1038         if( aReturnLeakCheckFail )

  1039             {

  1040             aReturnLeakCheckFail = EFalse;   // return first fail   

  1041 #ifndef STIF_DISABLE_LEAK_CHECK 

  1042             // Testcase is set to failed yet when handle leak occurred

  1043             TestExecution().FullResult().iTestResult.iResult = KErrGeneral;

  1044 #endif

  1045             TestExecution().FullResult().iTestResult.iResultDes = 

  1046                 _L("Thread handle leak from testmodule");

  1047             TestExecution().FullResult().iTestResult.iResultDes.

  1048                 AppendNum( aRequestCountAfterTest );

  1049             }

  1050         }       

  1051     }

  1052 

  1053 /*

  1054 -------------------------------------------------------------------------------

  1055 

  1056     Class: CTestThreadContainer

  1057 

  1058     Method: DeleteTestModule

  1059 

  1060     Description: Deletes a test module

  1061 

  1062     Parameters: None

  1063 

  1064     Return Values: None

  1065 

  1066     Errors/Exceptions: None

  1067 

  1068     Status: Proposal

  1069 

  1070 -------------------------------------------------------------------------------

  1071 */

  1072 void CTestThreadContainer::DeleteTestModule()

  1073     {

  1074 

  1075     __TRACEI ( KInit, ( _L("Deleting test module instance at 0x%x"), iTestModule ) );

  1076     // Delete the test module

  1077     ModuleContainer().OperationText() = _L("DESTRUCTOR");

  1078     TRAPD( r, delete iTestModule );

  1079     ModuleContainer().OperationText() = _L("");

  1080     iTestModule = NULL;

  1081 

  1082     if ( r )

  1083         {

  1084         __TRACEI ( KError, ( _L("Leave when deleting test module, code %d"), r ) );

  1085         }

  1086 

  1087     __TRACEI ( KInit, ( _L("Test module instance deleted") ) );

  1088 

  1089     }

  1090     

  1091     /*

  1092 -------------------------------------------------------------------------------

  1093 

  1094     Class: CTestThreadContainer

  1095 

  1096     Method: TestCases

  1097 

  1098     Description: Returns constant pointer to test case array

  1099 

  1100     Parameters: None

  1101     

  1102     Return Values: const RPointerArray<TTestCaseInfo>*  Test cases

  1103 

  1104     Errors/Exceptions: None

  1105 

  1106     Status: Proposal

  1107     

  1108 -------------------------------------------------------------------------------

  1109 */

  1110 const RPointerArray<TTestCaseInfo>* CTestThreadContainer::TestCases() const

  1111     {

  1112     

  1113     return iCases;

  1114 

  1115     }

  1116     

  1117 /*

  1118 -------------------------------------------------------------------------------

  1119 

  1120     Class: CTestThreadContainer

  1121 

  1122     Method: ErrorPrint

  1123 

  1124     Description: Prints error

  1125 

  1126     Parameters: const TInt aPriority :in: Priority

  1127                 TPtrC aError: in: Error

  1128 

  1129     Return Values: None

  1130 

  1131     Errors/Exceptions: None

  1132 

  1133     Status: Proposal

  1134