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: CStifTFwIf: This object executes test cases from 

    15 * STIF Test Framework.

    16 *

    17 */

    18 

    19 // INCLUDE FILES

    20 #include <e32base.h>

    21 #include <e32svr.h>

    22 #include "UIEngineEvent.h"

    23 #include <stifinternal/UIEngineContainer.h>

    24 #include "StifTFwIf.h"

    25 #include "StifTFw.h"

    26 #include "Logging.h"

    27 #include "StifPython.h"

    28 

    29 // EXTERNAL DATA STRUCTURES

    30 // None

    31 

    32 // EXTERNAL FUNCTION PROTOTYPES

    33 // None

    34 

    35 // CONSTANTS

    36 // None

    37 

    38 // MACROS

    39 #ifdef LOGGER

    40 #undef LOGGER

    41 #endif

    42 #define LOGGER iStifTFw->iLogger

    43 

    44 // LOCAL CONSTANTS AND MACROS

    45 // None

    46 

    47 // MODULE DATA STRUCTURES

    48 // None

    49 

    50 // LOCAL FUNCTION PROTOTYPES

    51 // None

    52 

    53 // FORWARD DECLARATIONS

    54 // None

    55 

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

    57 

    58 // ================= MEMBER FUNCTIONS =========================================

    59 

    60 /*

    61 -------------------------------------------------------------------------------

    62 

    63     Class: CStifTFwIf

    64 

    65     Method: CStifTFwIf

    66 

    67     Description: Default constructor

    68 

    69     C++ default constructor can NOT contain any code, that

    70     might leave.

    71     

    72     Parameters: None

    73     

    74     Return Values: None

    75 

    76     Errors/Exceptions: None

    77 

    78     Status: Draft

    79 

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

    81 */

    82 EXPORT_C CStifTFwIf::CStifTFwIf()

    83     {

    84     __RDEBUG( _L( "CStifTFwIf::CStifTFwIf()" ) );

    85     }

    86 

    87 

    88 /*

    89 -------------------------------------------------------------------------------

    90 

    91     Class: CStifTFwIf

    92 

    93     Method: ~CStifTFwIf

    94 

    95     Description: Destructor

    96 

    97     Parameters: None

    98 

    99     Return Values: None

   100 

   101     Errors/Exceptions: None

   102 

   103     Status: Draft

   104 

   105 -------------------------------------------------------------------------------

   106 */

   107 EXPORT_C CStifTFwIf::~CStifTFwIf()

   108     {

   109     __RDEBUG( _L( "CStifTFwIf::~CStifTFwIf()" ) );

   110     }

   111 

   112 /*

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

   114 

   115     Class: CStifTFwIf

   116 

   117     Method: Open

   118 

   119     Description: Open test engine.

   120 

   121     Parameters: TDesC& aTestFrameworkIni: in: Initialization file to Test Framework

   122 

   123     Return Values: Symbian OS error: Error code

   124 

   125     Errors/Exceptions: None

   126 

   127     Status: Draft

   128 

   129 -------------------------------------------------------------------------------

   130 */

   131 EXPORT_C TInt CStifTFwIf::Open( TDesC& aTestFrameworkIni )

   132     {

   133     RDebug::Print(_L("CStifTFwIf::Open"));

   134     TInt err( KErrNone );

   135     TRAP( err,

   136         iStifTFw = CStifTFw::NewL( this );

   137         )

   138 

   139     return iStifTFw->iUIEngine->Open( aTestFrameworkIni );

   140 

   141     }

   142 

   143 

   144 /*

   145 -------------------------------------------------------------------------------

   146 

   147     Class: CStifTFwIf

   148 

   149     Method: Close

   150 

   151     Description: Close test engine.

   152 

   153     Parameters: None

   154 

   155     Return Values: TInt KErrNone: Always returned KErrNone

   156 

   157     Errors/Exceptions: None

   158 

   159     Status: Draft

   160 

   161 -------------------------------------------------------------------------------

   162 */

   163 EXPORT_C TInt CStifTFwIf::Close()

   164     {

   165     RDebug::Print(_L("CStifTFwIf::Close"));

   166 

   167     iStifTFw->DeleteData(); //Delete objects before closing session to TestEngine server

   168     iStifTFw->iUIEngine->Close();

   169 

   170     delete iStifTFw;

   171     iStifTFw = 0;

   172 

   173     return KErrNone;

   174 

   175     }

   176 

   177 

   178 /*

   179 -------------------------------------------------------------------------------

   180 

   181     Class: CStifTFwIf

   182 

   183     Method: SetAttribute

   184 

   185     Description: Used to set attributes for Test Framework.

   186 

   187     Parameters: TAttribute aAttribute: in: Attribute type

   188                 TDesC& aValue: in: Attribute value

   189 

   190     Return Values: Symbian OS error: Error code

   191 

   192     Errors/Exceptions: None

   193 

   194     Status: Proposal

   195 

   196 -------------------------------------------------------------------------------

   197 */

   198 EXPORT_C TInt CStifTFwIf::SetAttribute( TAttribute aAttribute,

   199                                         const TDesC& aValue )

   200     {

   201     RDebug::Print(_L("CStifTFwIf::SetAttribute"));

   202     // Check aValue max length

   203     if( aValue.Length() > KMaxName )

   204         {

   205         __TRACE( KPrint, ( CStifLogger::EError, _L( "CStifTFwIf::SetAttribute() method's second parameter length is incorrect" ) ) );

   206         return KErrArgument;

   207         }

   208 

   209     TInt ret = iStifTFw->iUIEngine->TestEngine().SetAttribute( aAttribute, aValue );

   210 

   211     if ( ret != KErrNone )

   212         {

   213         __TRACE( KPrint, ( _L( "CStifTFwIf::SetAttribute() method fails with error:%d" ), ret  ) );

   214         return ret;

   215         }

   216 

   217     return KErrNone;

   218 

   219     }

   220 

   221 /*

   222 -------------------------------------------------------------------------------

   223 

   224     Class: CStifTFwIf

   225 

   226     Method: AddTestModule

   227 

   228     Description: Add test module to module list of test engine

   229 

   230     Parameters: TDesC& aModuleName: in: Testmodule, which is added to module list

   231                 TDesC& aIniFile: in: Initialization file to the test module

   232 

   233     Return Values: Symbian OS error: Error code

   234 

   235     Errors/Exceptions: None

   236 

   237     Status: Draft

   238 

   239 -------------------------------------------------------------------------------

   240 */

   241 EXPORT_C TInt CStifTFwIf::AddTestModule( TDesC& aModuleName,

   242                                          TDesC& aIniFile )

   243     {

   244     RDebug::Print(_L("CStifTFwIf::AddTestModule"));

   245 

   246     return iStifTFw->iUIEngine->AddTestModule( aModuleName, aIniFile );

   247 

   248     }

   249 

   250 

   251 /*

   252 -------------------------------------------------------------------------------

   253 

   254     Class: CStifTFwIf

   255 

   256     Method: RemoveTestModule

   257 

   258     Description: Add test module to module list of test engine

   259 

   260     Parameters: TDesC& aModuleName: in: Testmodule, which is removed of module list

   261 

   262     Return Values: Symbian OS error: Error code

   263 

   264     Errors/Exceptions: None

   265 

   266     Status: Draft

   267 

   268 -------------------------------------------------------------------------------

   269 */

   270 EXPORT_C TInt CStifTFwIf::RemoveTestModule( TDesC& aModuleName )

   271     {

   272     RDebug::Print(_L("CStifTFwIf::RemoveTestModule"));

   273 

   274     return iStifTFw->iUIEngine->RemoveTestModule( aModuleName );

   275 

   276     }

   277 

   278 

   279 /*

   280 -------------------------------------------------------------------------------

   281 

   282     Class: CStifTFwIf

   283 

   284     Method: AddTestCaseFile

   285 

   286     Description: Add test case file to test case file list of test engine

   287 

   288     Parameters: TDesC& aModuleName: in: Testmodule, which own test cases of test case list.

   289                 TDesC& aCaseFile: in: Test case list, which is added to test case list

   290 

   291     Return Values: Symbian OS error: Error code

   292 

   293     Errors/Exceptions: None

   294 

   295     Status: Draft

   296 

   297 -------------------------------------------------------------------------------

   298 */

   299 EXPORT_C TInt CStifTFwIf::AddTestCaseFile( TDesC& aModuleName, TDesC& aCaseFile )

   300     {

   301     RDebug::Print(_L("CStifTFwIf::AddTestCaseFile"));

   302 

   303     return iStifTFw->iUIEngine->AddTestCaseFile( aModuleName, aCaseFile );

   304 

   305     }

   306 

   307 

   308 /*

   309 -------------------------------------------------------------------------------

   310 

   311     Class: CStifTFwIf

   312 

   313     Method: RemoveTestCaseFile

   314 

   315     Description: Remove test case file of test case file list of test engine

   316 

   317     Parameters: TDesC& aModuleName: in: Testmodule, which own test cases of test case list

   318                 TDesC& aCaseFile: in: Test case list, which is removed of test case list

   319 

   320     Return Values: Symbian OS error: Error code

   321 

   322     Errors/Exceptions: None

   323 

   324     Status: Draft

   325 

   326 -------------------------------------------------------------------------------

   327 */

   328 EXPORT_C TInt CStifTFwIf::RemoveTestCaseFile( TDesC& aModuleName, TDesC& aCaseFile )

   329     {

   330     RDebug::Print(_L("CStifTFwIf::RemoveTestCaseFile"));

   331 

   332     return iStifTFw->iUIEngine->RemoveTestCaseFile( aModuleName, aCaseFile );

   333 

   334     }

   335 

   336 

   337 /*

   338 -------------------------------------------------------------------------------

   339 

   340     Class: CStifTFwIf

   341 

   342     Method: GetTestCases

   343 

   344     Description: Get test cases of enumerated list of test engine. Method is copied

   345                  list of test cases to aTestCaseInfo. Copied tests are test cases

   346                  of test module (aTestModule) and defined

   347                  in test case file (aTestCaseFile), which are given as argument

   348 

   349                  Method copied all enumerated test cases if aTestModule

   350                  and aTestCaseFile are not defined

   351 

   352     Parameters: RPointerArray<CTestInfo>& aTestCaseInfo: inout: List of test cases

   353                 TDesC& aModuleName: in: Testmodule, which own test cases of test case list

   354                 TDesC& aTestCaseFile: in: Test case list, which is got of test case list

   355 

   356     Return Values: Symbian OS error: Error code

   357 

   358     Errors/Exceptions: None

   359 

   360     Status: Draft

   361 

   362 -------------------------------------------------------------------------------

   363 */

   364 EXPORT_C TInt CStifTFwIf::GetTestCases( RPointerArray<CTestInfo>& aTestCaseInfo,

   365                                         TDesC& aTestModule,

   366                                         TDesC& aTestCaseFile )

   367     {

   368     RDebug::Print(_L("CStifTFwIf::GetTestCases"));

   369 

   370     TRAPD( ret,

   371         ret = iStifTFw->iUIEngine->GetTestCasesL( aTestCaseInfo,

   372                                                   aTestModule,

   373                                                   aTestCaseFile );

   374         );

   375 

   376     return ret;

   377 

   378     }

   379 

   380 

   381 /*

   382 -------------------------------------------------------------------------------

   383 

   384     Class: CStifTFwIf

   385 

   386     Method: StartTestCase

   387 

   388     Description: Start test case execution.

   389 

   390     Parameters: TInt& aTestId: in: ID for test case. Test ID given of address of

   391                 current CStifTFwIfContainer.

   392 

   393                 const CTestInfo& aTestInfo: in: Test case information

   394 

   395     Return Values: Symbian OS error: Error code

   396 

   397     Errors/Exceptions: None

   398 

   399     Status: Draft

   400 

   401 -------------------------------------------------------------------------------

   402 */

   403 EXPORT_C TInt CStifTFwIf::StartTestCase( TInt& aTestId,

   404                                          const CTestInfo& aTestInfo )

   405     {

   406     RDebug::Print(_L("CStifTFwIf::StartTestCase"));

   407 

   408     CUIEngineContainer* container = NULL;

   409 

   410     TInt ret = iStifTFw->iUIEngine->StartTestCase( container,

   411                                                    aTestInfo );

   412 

   413     if( ret != KErrNone )

   414         {

   415         return ret;

   416         }

   417 

   418     // Add container to test case execution table

   419     ret = iStifTFw->iTestExecutionTable.Append( container );

   420     if( ret != KErrNone )

   421         {

   422         iStifTFw->iUIEngine->AbortStartedTestCase( container );

   423         return ret;

   424         }

   425 

   426     // Get test id.

   427     aTestId = (TInt)container;

   428 

   429     __TRACE( KPrint, (  _L( "aTestId: %d"), aTestId ) );

   430     __TRACE( KPrint, (  _L( "aTest case: %S"), &(aTestInfo.TestCaseTitle()) ) );

   431 

   432     return ret;

   433 

   434     }

   435 

   436 

   437 /*

   438 -------------------------------------------------------------------------------

   439 

   440     Class: CStifTFwIf

   441 

   442     Method: CancelTestCase

   443 

   444     Description: Cancel test case execution

   445 

   446     Parameters: TInt& aTestId: in: ID for test case

   447 

   448     Return Values: Symbian OS error: Error code

   449 

   450     Errors/Exceptions: None

   451 

   452     Status: Draft

   453 

   454 -------------------------------------------------------------------------------

   455 */

   456 EXPORT_C TInt CStifTFwIf::CancelTestCase( TInt aTestId )

   457     {

   458     RDebug::Print(_L("CStifTFwIf::CancelTestCase"));

   459     TInt ret(KErrNone);

   460 

   461     // Find test case from execution table

   462     TInt index = iStifTFw->iTestExecutionTable.Find( ( CUIEngineContainer* )aTestId );

   463 

   464     // Check if test id is found

   465     if( index < 0)

   466         {

   467         __TRACE( KPrint, (  _L( "CStifTFwIf::CancelTestCase. Container not found. TestId = %d"), aTestId ) );

   468 

   469         return index;

   470         }

   471 

   472     // Cancel test

   473     ret = iStifTFw->iTestExecutionTable[index]->CancelTest();

   474     __TRACE( KPrint, (  _L( "CStifTFwIf::CancelTestCase. Canceled testId %d"), aTestId ) );

   475 

   476     return ret;

   477     }

   478 

   479 

   480 /*

   481 -------------------------------------------------------------------------------

   482 

   483     Class: CStifTFwIf

   484 

   485     Method: PauseTestCase

   486 

   487     Description: Pause test case execution

   488 

   489     Parameters: TInt& aTestId: in: ID for test case

   490 

   491     Return Values: Symbian OS error: Error code

   492 

   493     Errors/Exceptions: None

   494 

   495     Status: Draft

   496 

   497 -------------------------------------------------------------------------------

   498 */

   499 EXPORT_C TInt CStifTFwIf::PauseTestCase(  TInt aTestId  )

   500     {

   501     RDebug::Print(_L("CStifTFwIf::PauseTestCase"));

   502     TInt ret(KErrNone);

   503 

   504     // Find test case from execution table

   505     TInt index = iStifTFw->iTestExecutionTable.Find( ( CUIEngineContainer*) aTestId );

   506 

   507     // Check if test id is found

   508     if( index < 0 )

   509         {

   510         __TRACE( KPrint, (  _L( "CStifTFwIf::PauseTestCase. Container not found: testId = %d"), aTestId ) );

   511 

   512         return index;

   513         }

   514 

   515     // Pause test

   516     ret = iStifTFw->iTestExecutionTable[index]->PauseTest();

   517 

   518     __TRACE( KPrint, (  _L( "CStifTFwIf::PauseTest. Paused testId %d"), aTestId ) );

   519     return ret;

   520     }

   521 

   522 

   523 /*

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

   525 

   526     Class: CStifTFwIf

   527 

   528     Method: ResumeTestCase

   529 

   530     Description: Resume test case execution

   531 

   532     Parameters: TInt& aTestId: in: ID for test case

   533 

   534     Return Values: Symbian OS error: Error code

   535 

   536     Errors/Exceptions: None

   537 

   538     Status: Draft

   539 

   540 -------------------------------------------------------------------------------

   541 */

   542 EXPORT_C TInt CStifTFwIf::ResumeTestCase( TInt aTestId )

   543     {

   544     RDebug::Print(_L("CStifTFwIf::ResumeTestCase"));

   545     TInt ret(KErrNone);

   546 

   547     // Find test case from execution table

   548     TInt index = iStifTFw->iTestExecutionTable.Find( ( CUIEngineContainer* ) aTestId );

   549 

   550     // Check if test id is found

   551     if( index < 0 )

   552         {

   553         __TRACE( KPrint, (  _L( "CStifTFwIf::ResumeTestCase. Container not found: TestId = %d"), aTestId ) );

   554 

   555         return index;

   556         }

   557 

   558     // Resume test

   559     ret = iStifTFw->iTestExecutionTable[index]->ResumeTest();

   560 

   561     __TRACE( KPrint, ( _L( "CStifTFwIf::ResumeTestCase. Resumed testId %d"), aTestId ) );

   562 

   563     return ret;

   564     }

   565 

   566 

   567 /*

   568 -------------------------------------------------------------------------------

   569 

   570     Class: CStifTFwIf

   571 

   572     Method: AtsReceive

   573 

   574     Description: Handles remote protocol message receives

   575 

   576     Parameters: const TDesC& aMessage: in: Protocol message received

   577 

   578     Return Values: Symbian OS error code: In oom and is protocol message header

   579         parsing fails, i.e. error in <msgtype> <srcid> <dstid>

   580 

   581     Errors/Exceptions: None

   582 

   583     Status: Draft

   584 

   585 -------------------------------------------------------------------------------

   586 */

   587 EXPORT_C TInt CStifTFwIf::AtsReceive( const TDesC& aMessage )

   588     {

   589     RDebug::Print(_L("CStifTFwIf::AtsReceive"));

   590 

   591     CStifTFwIfProt* msg = NULL;

   592     CStifTFwIfProt* resp = NULL;

   593     TRAPD( err, msg = CStifTFwIfProt::NewL(); );

   594     if( err != KErrNone )

   595         {

   596         return err;

   597         }

   598     TRAP( err, resp = CStifTFwIfProt::NewL(); );

   599     if( err != KErrNone )

   600         {

   601         delete msg;

   602         return err;

   603         }

   604     TInt error = KErrNone;

   605     TInt ret = KErrNone;

   606 

   607     // Parse received message

   608     TRAP( err,

   609         error = msg->SetL( aMessage )

   610     );

   611     if( err != KErrNone )

   612         {

   613         __TRACE( KError, ( _L( "AtsReceive: message header parsing failed [%d]"), err ) );

   614         delete msg;

   615         delete resp;

   616         return err;

   617         }

   618 

   619     // Create response

   620     TRAP( err, resp->CreateL(); );

   621     if( err != KErrNone )

   622         {

   623         delete msg;

   624         delete resp;

   625         return err;

   626         }

   627 

   628     resp->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgResponse );

   629 

   630     if( error != KErrNone )

   631         {

   632         __TRACE( KError, ( _L( "AtsReceive: message parsing failed [%d]"), error ) );

   633         resp->AppendId( SETID( DevId(), 0 ) );

   634         resp->AppendId( msg->SrcId() );

   635         resp->Append( CStifTFwIfProt::MsgType, msg->iMsgType );

   636         resp->Append( CStifTFwIfProt::RespParam, CStifTFwIfProt::ERespResult, error );

   637         AtsSend( resp->Message() );

   638 

   639         // Error reported with protocol message, return success

   640         delete msg;

   641         delete resp;

   642         return KErrNone;

   643         }

   644 

   645     switch( msg->iMsgType )

   646         {

   647         case CStifTFwIfProt::EMsgReserve:

   648             {

   649             if( msg->iRemoteType != CStifTFwIfProt::ERemotePhone )

   650                 {

   651                 __TRACE( KError, ( _L( "AtsReceive: reserve for illegal type received") ) );

   652                 error = KErrGeneral;

   653                 }

   654             // Check IDs

   655             if( ( msg->SrcDevId() == 0 ) ||

   656                 ( msg->SrcTestId() == 0 ) )

   657                 {

   658                 __TRACE( KError, ( _L( "AtsReceive: reserve for illegal srcid received") ) );

   659                 error = KErrGeneral;

   660                 }

   661             if( msg->DstId() != 0 )

   662                 {

   663                 // Not a broadcast

   664                 if( ( msg->DstDevId() != DevId() ) ||

   665                     ( msg->DstTestId() != 0 ) )

   666                     {

   667                     __TRACE( KError, ( _L( "AtsReceive: reserve for illegal dstid received") ) );

   668                     error = KErrGeneral;

   669                     }

   670                 }

   671             TInt index = iStifTFw->iMasterArray.Find( msg->SrcId() );

   672             if( index >= 0 )

   673                 {

   674                 error = KErrInUse;

   675                 __TRACE( KError, ( _L( "AtsReceive: master has already reserved slave") ) );

   676                 }

   677             else

   678                 {

   679                 iStifTFw->iMasterArray.Append( msg->SrcId() );

   680                 }

   681 

   682             resp->AppendId( SETID( DevId(), 0 ) );

   683             resp->AppendId( msg->SrcId() );

   684             resp->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgReserve );

   685             if( error != KErrNone )

   686                 {

   687                 resp->Append( CStifTFwIfProt::RespParam, CStifTFwIfProt::ERespResult, error );

   688                 }

   689             AtsSend( resp->Message() );

   690 

   691             }

   692             break;

   693         case CStifTFwIfProt::EMsgRelease:

   694             {

   695             // Check protocol ids

   696             if( ( msg->SrcDevId() == 0 ) ||

   697                 ( msg->SrcTestId() == 0 ) ||

   698                 ( msg->DstTestId() != 0 ) )

   699                 {

   700                 __TRACE( KError, ( _L( "AtsReceive: release for illegal srcid or dstid received") ) );

   701                 error = KErrGeneral;

   702                 }

   703             else if( msg->DstDevId() != DevId() )

   704                 {

   705                 __TRACE( KError, ( _L( "AtsReceive: release for illegal dstid received") ) );

   706                 error = KErrNotFound;

   707                 }

   708             else

   709                 {

   710                 // Check Master identifier

   711                 // First check that specific master has reserved us

   712                 TInt index = iStifTFw->iMasterArray.Find( msg->SrcId() );

   713                 if( index < 0 )

   714                     {

   715                     error = KErrNotFound;

   716                     }

   717                 else

   718                     {

   719                     // Search test case from execution table

   720                     TInt count = iStifTFw->iTestRemoteExecutionTable.Count();

   721                     for( TInt ind = 0; ind < count; ind++ )

   722                         {

   723                         if( iStifTFw->iTestRemoteExecutionTable[ind]->RemoteId() ==

   724                             msg->SrcId() )

   725                             {

   726                             __TRACE( KError, (  _L( "Release: test case running for %x"),

   727                                 msg->SrcId() ) );

   728                             error = KErrInUse;

   729                             break;

   730                             }

   731                         }

   732                     if( error == KErrNone )

   733                         {

   734                         iStifTFw->iMasterArray.Remove( index );

   735                         }

   736                     }

   737                 }

   738 

   739             resp->AppendId( msg->DstId() );

   740             resp->AppendId( msg->SrcId() );

   741             resp->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRelease );

   742 

   743             if( error != KErrNone )

   744                 {

   745                 resp->Append( CStifTFwIfProt::RespParam, CStifTFwIfProt::ERespResult, error );

   746                 }

   747             AtsSend( resp->Message() );

   748             }

   749             break;

   750         case CStifTFwIfProt::EMsgRemote:

   751             {

   752             // Check protocol ids

   753             TInt index = iStifTFw->iMasterArray.Find( msg->SrcId() );

   754             if( ( msg->SrcDevId() == 0 ) ||

   755                 ( msg->SrcTestId() == 0 ) ||

   756                 ( msg->DstDevId() == 0 ) )

   757                 {

   758                 __TRACE( KError, ( _L( "AtsReceive: remote for illegal srcid or dstid received") ) );

   759                 error = KErrGeneral;

   760                 }

   761             else if( index < 0 )

   762                 {

   763                 __TRACE( KError, ( _L( "AtsReceive: remote for illegal srcid received") ) );

   764                 error = KErrNotFound;

   765                 }

   766             else

   767                 {

   768 

   769                 __TRACE( KError, ( _L( "AtsReceive: Call AtsRemote") ) );

   770                 RDebug::Print(_L("CStifTFwIf::AtsReceive remote command received, calling AtsRemote"));

   771                 error = iStifTFw->AtsRemote( *msg, *resp );

   772                 RDebug::Print(_L("CStifTFwIf::AtsReceive remote command received, AtsRemote return"));

   773                 }

   774 

   775             if( error != KErrNone )

   776                 {

   777                 resp->AppendId( msg->DstId() );

   778                 resp->AppendId( msg->SrcId() );

   779                 resp->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote );

   780                 resp->Append( CStifTFwIfProt::CmdType, msg->iCmdType );

   781                 resp->Append( CStifTFwIfProt::RespParam,

   782                              CStifTFwIfProt::ERespResult,

   783                              error );

   784                 }

   785             AtsSend( resp->Message() );

   786             }

   787             break;

   788         case CStifTFwIfProt::EMsgResponse:

   789             {

   790             // Responses ae forwarded to master

   791             CUIEngineContainer* container = NULL;

   792             TInt count = iStifTFw->iTestRemoteExecutionTable.Count();

   793             TInt index = 0;

   794             for( index = 0 ; index < count; index++ )

   795                 {

   796                 if( iStifTFw->iTestRemoteExecutionTable[index]->MasterId() ==

   797                     msg->SrcId() )

   798                     {

   799                     __TRACE( KError, (  _L( "Response for %x"),

   800                         msg->SrcId() ) );

   801                     container = iStifTFw->iTestRemoteExecutionTable[index];

   802                     break;

   803                     }

   804                 }

   805             if( container == NULL )

   806                 {

   807                 count = iStifTFw->iTestExecutionTable.Count();

   808                 for( index = 0 ; index < count; index++ )

   809                     {

   810                     if( iStifTFw->iTestExecutionTable[index]->MasterId() ==

   811                         msg->DstId() )

   812                         {

   813                         __TRACE( KError, (  _L( "Response for %x"),

   814                             msg->SrcId() ) );

   815                         container = iStifTFw->iTestExecutionTable[index];

   816                         break;

   817                         }

   818                     }

   819                 }

   820 

   821             if( container == NULL )

   822                 {

   823                 __TRACE( KError, ( _L( "AtsReceive: response to srcid %x that is not a running master"),

   824                     msg->SrcId() ) );

   825                 ret = KErrNotFound;

   826                 }

   827             else

   828                 {

   829                 ret = container->RemoteReceive( aMessage );

   830                 }

   831             }

   832             break;

   833         default:

   834             __TRACE( KError, ( _L( "AtsReceive: invalid message")) );

   835             ret = KErrNotSupported;

   836         }

   837 

   838     delete msg;

   839     delete resp;

   840     return ret;

   841 

   842     }

   843 

   844 /*

   845 -------------------------------------------------------------------------------

   846 

   847     DESCRIPTION

   848 

   849     CStifTFw: This object executes test cases from STIF Test Framework.

   850 

   851 -------------------------------------------------------------------------------

   852 */

   853 

   854 // MACROS

   855 #ifdef LOGGER

   856 #undef LOGGER

   857 #endif

   858 #define LOGGER iLogger

   859 

   860 // ================= MEMBER FUNCTIONS =========================================

   861 

   862 /*

   863 -------------------------------------------------------------------------------

   864 

   865     Class: CStifTFw

   866 

   867     Method: NewL

   868 

   869     Description: Construct the CStifTFw class

   870 

   871     Parameters: None

   872 

   873     Return Values: CStifTFw*                    New object

   874 

   875     Errors/Exceptions: Leaves if memory allocation fails or

   876                        ConstructL leaves.

   877 

   878     Status: Draft

   879 

   880 -------------------------------------------------------------------------------

   881 */

   882 CStifTFw* CStifTFw::NewL( CStifTFwIf* aStifTFwIf )

   883     {

   884     RDebug::Print(_L("CStifTFw::NewL"));

   885 

   886     CStifTFw* self = new ( ELeave ) CStifTFw( aStifTFwIf );

   887     CleanupStack::PushL( self );

   888     self->ConstructL();

   889     CleanupStack::Pop( self );

   890 

   891     return self;

   892 

   893     }

   894 

   895 

   896 /*

   897 -------------------------------------------------------------------------------

   898 

   899     Class: CStifTFw

   900 

   901     Method: ConstructL

   902 

   903     Description: Second level constructor.

   904 

   905     Parameters: None

   906 

   907     Return Values: None

   908 

   909     Errors/Exceptions: Leaves on error

   910 

   911     Status: Draft

   912 

   913 -------------------------------------------------------------------------------

   914 */

   915 void CStifTFw::ConstructL()

   916     {

   917     RDebug::Print(_L("CStifTFw::ConstructL"));

   918 

   919     iUIEngine = CUIEngine::NewL( (CUIIf*) this );

   920 

   921     }

   922 

   923 

   924 /*

   925 -------------------------------------------------------------------------------

   926 

   927     Class: CStifTFw

   928 

   929     Method: CStifTFw

   930 

   931     Description: Default constructor

   932 

   933     C++ default constructor can NOT contain any code, that

   934     might leave.

   935 

   936     Parameters: None

   937 

   938     Return Values: None

   939 

   940     Errors/Exceptions: None

   941 

   942     Status: Draft

   943 

   944 -------------------------------------------------------------------------------

   945 */

   946 CStifTFw::CStifTFw( CStifTFwIf* aStifTFwIf ):

   947     iStifTFwIf( aStifTFwIf )

   948     {

   949 

   950     __RDEBUG( _L( "CStifTFw::CStifTFw()" ) );

   951 

   952     }

   953 

   954 

   955 /*

   956 -------------------------------------------------------------------------------

   957 

   958     Class: CStifTFwIf

   959 

   960     Method: ~CStifTFwIf

   961 

   962     Description: Destructor

   963 

   964     Parameters: None

   965 

   966     Return Values: None

   967 

   968     Errors/Exceptions: None

   969 

   970     Status: Draft

   971 

   972 -------------------------------------------------------------------------------

   973 */

   974 CStifTFw::~CStifTFw()

   975     {

   976     __RDEBUG( _L( "CStifTFw::~CStifTFw() begin" ) );

   977 

   978     RDebug::Print(_L("CStifTFw::~CStifTFw resetting iTestExecutionTable cnt=%d"), iTestExecutionTable.Count());

   979     iTestExecutionTable.Reset();

   980     RDebug::Print(_L("CStifTFw::~CStifTFw resetting iTestRemoteExecutionTable cnt=%d"), iTestRemoteExecutionTable.Count());

   981     iTestRemoteExecutionTable.Reset();

   982     RDebug::Print(_L("CStifTFw::~CStifTFw resetting iEventArray cnt=%d"), iEventArray.Count());

   983     iEventArray.ResetAndDestroy();

   984     RDebug::Print(_L("CStifTFw::~CStifTFw resetting iMasterArray cnt=%d"), iMasterArray.Count());

   985     iMasterArray.Reset();

   986 

   987     RDebug::Print(_L("CStifTFw::~CStifTFw closing iTestExecutionTable cnt=%d"), iTestExecutionTable.Count());

   988     iTestExecutionTable.Close();

   989     RDebug::Print(_L("CStifTFw::~CStifTFw closing iTestRemoteExecutionTable cnt=%d"), iTestRemoteExecutionTable.Count());

   990     iTestRemoteExecutionTable.Close();

   991     RDebug::Print(_L("CStifTFw::~CStifTFw closing iEventArray cnt=%d"), iEventArray.Count());

   992     iEventArray.Close();

   993     RDebug::Print(_L("CStifTFw::~CStifTFw closing iMasterArray cnt=%d"), iMasterArray.Count());

   994     iMasterArray.Close();

   995 

   996     //Moved from the beginning of destructor, because objects from some arrays during resetting and/or closing

   997     //have tried to call methods of iUIEngine.

   998     RDebug::Print(_L("CStifTFw::~CStifTFw deleteing iUiEngine address=%d"), iUIEngine);

   999     delete iUIEngine;

  1000 

  1001     RDebug::Print(_L("CStifTFw::~CStifTFw end"));

  1002     }

  1003 

  1004 /*

  1005 -------------------------------------------------------------------------------

  1006 

  1007     Class: CStifTFw

  1008 

  1009     Method: AtsRemote

  1010 

  1011     Description: Remote ATS call

  1012 

  1013     Parameters: const TDesC& aMessage: in:

  1014 

  1015     Return Values: KErrNotSupported

  1016 

  1017     Errors/Exceptions: None

  1018 

  1019     Status: Draft

  1020 

  1021 -------------------------------------------------------------------------------

  1022 */

  1023 TInt CStifTFw::AtsRemote( CStifTFwIfProt& aReq, CStifTFwIfProt& aResp )

  1024     {

  1025     RDebug::Print(_L("CStifTFw::AtsRemote start, iCmdType=%d "), aReq.iCmdType);

  1026 

  1027     TInt ret = KErrNone;

  1028 

  1029     switch( aReq.iCmdType )

  1030         {

  1031         case CStifTFwIfProt::ECmdRun:

  1032             {

  1033             RDebug::Print(_L("CStifTFw::AtsRemote iCmdType CStifTFwIfProt::ECmdRun "));

  1034             ret = AtsRemoteRun( aReq, aResp );

  1035             break;

  1036             }

  1037         case CStifTFwIfProt::ECmdPause:

  1038         case CStifTFwIfProt::ECmdResume:

  1039         case CStifTFwIfProt::ECmdCancel:

  1040             {

  1041             RDebug::Print(_L("CStifTFw::AtsRemote iCmdType CStifTFwIfProt::ECmdPause,Resume,Cancel "));

  1042             ret = AtsRemoteTestCtl( aReq, aResp );

  1043             break;

  1044             }

  1045         case CStifTFwIfProt::ECmdRequest:

  1046         case CStifTFwIfProt::ECmdRelease:

  1047             {

  1048             RDebug::Print(_L("CStifTFw::AtsRemote iCmdType CStifTFwIfProt::ECmdRequest,Release "));

  1049             ret = AtsRemoteEventCtl( aReq, aResp );

  1050             break;

  1051             }

  1052         case CStifTFwIfProt::ECmdSetEvent:

  1053         case CStifTFwIfProt::ECmdUnsetEvent:

  1054         	{

  1055             RDebug::Print(_L("CStifTFw::AtsRemote iCmdType CStifTFwIfProt::ECmdSetEvent,Unset start "));

  1056             ret = AtsRemoteEventCtl( aReq, aResp );

  1057             RDebug::Print(_L("CStifTFw::AtsRemote iCmdType CStifTFwIfProt::ECmdSetEvent,Unset end "));

  1058             break;

  1059 			}

  1060         default:

  1061             {

  1062             RDebug::Print(_L("CStifTFw::AtsRemote iCmdType UNSUPPORTED value=%d "), aReq.iCmdType);

  1063             return KErrNotSupported;

  1064             }

  1065         }

  1066 

  1067     return ret;

  1068     }

  1069 

  1070 /*

  1071 -------------------------------------------------------------------------------

  1072 

  1073      Class: CStifTFw

  1074 

  1075      Method: GetCaseNumByTitle

  1076 

  1077      Description: Enumerates test cases from given module and finds test case index by title

  1078 

  1079      Parameters:    TDesC& aModule: in: module name

  1080                     TDesC& aTestCaseFile: in: cfg file

  1081 	                TDesC& aTitle: in: test case title

  1082                     TInt& aCaseNum: in out: test case index

  1083 

  1084      Return Values: KErrNone if everything is ok

  1085                     KErrNotFound if there is no such test case

  1086 

  1087      Errors/Exceptions: None.

  1088 

  1089      Status: Proposal

  1090 

  1091 -------------------------------------------------------------------------------

  1092 */

  1093 TInt CStifTFw::GetCaseNumByTitle(TDesC& aModule, TDesC& aTestCaseFile, TDesC& aTitle, TInt& aCaseNum)

  1094     {

  1095     RDebug::Print(_L("CStifTFw::GetCaseNumByTitle looking for test case number module=[%S] cfg=[%S] title=[%S]"), &aModule, &aTestCaseFile, &aTitle);

  1096 	//Allocate table

  1097     RPointerArray<CTestInfo> allTestInfos;

  1098     CleanupClosePushL(allTestInfos);

  1099     TInt ret = KErrNone;

  1100 

  1101     //Enumerate test cases

  1102     RDebug::Print(_L("CStifTFw::GetCaseNumByTitle enumerating test cases"));

  1103     if(aTestCaseFile == _L("dummy.cfg"))

  1104         {

  1105 		TName t = _L("");

  1106         ret = iStifTFwIf->GetTestCases(allTestInfos, aModule, t);

  1107 		}

  1108     else

  1109         {

  1110         ret = iStifTFwIf->GetTestCases(allTestInfos, aModule, aTestCaseFile);

  1111 		}

  1112 

  1113     if(ret != KErrNone)

  1114         {

  1115 		RDebug::Print(_L("Test cases enumeration from module [%S] and file [%S] has returned an error %d"), &aModule, &aTestCaseFile, ret);

  1116 		}

  1117     else

  1118         {

  1119 		//Searching through the table

  1120         RDebug::Print(_L("CStifTFw::GetCaseNumByTitle searching through the test cases table containing %d cases"), allTestInfos.Count());

  1121         ret = KErrNotFound;

  1122         for(TInt i = 0; i < allTestInfos.Count(); i++)

  1123             {

  1124             if(allTestInfos[i]->TestCaseTitle() == aTitle)

  1125                 {

  1126                 aCaseNum = i;

  1127                 //TestScripter relies on 1-based indexing

  1128                 if((aModule.Find(KTestScripterName) != KErrNotFound) || (aModule.Find(KPythonScripter) != KErrNotFound) || (aModule.Find(KTestCombinerName) != KErrNotFound)) 

  1129                     aCaseNum++;

  1130                 ret = KErrNone;

  1131                 break;

  1132                 }

  1133             }

  1134 		}

  1135 	if(ret == KErrNotFound)