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:  Implements the functions to control STIF Test Framework

    15 *                through the STIF TF interface.

    16 *

    17 */

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include <badesca.h>

    23 #include <bautils.h>

    24 #include <charconv.h>

    25 #include <e32cons.h>

    26 #include <HtiLogging.h>

    27 #include "HtiStifTfIf.h"

    28 

    29 // EXTERNAL DATA STRUCTURES

    30 

    31 // EXTERNAL FUNCTION PROTOTYPES

    32 

    33 // CONSTANTS

    34 

    35 // MACROS

    36 

    37 // LOCAL CONSTANTS AND MACROS

    38 const static TUid KStifTfServiceUid = { 0x10210CC3 };

    39 

    40 enum TStifTfCommands

    41     {

    42     ECmdOpen            = 0x01,

    43     ECmdClose           = 0x02,

    44     ECmdLoadModule      = 0x03,

    45     ECmdUnloadModule    = 0x04,

    46     ECmdListCases       = 0x05,

    47     ECmdStartCase       = 0x06,

    48     ECmdCancelCase      = 0x07,

    49     ECmdPauseCase       = 0x08,

    50     ECmdResumeCase      = 0x09,

    51     ECmdAddCaseFile     = 0x0A,

    52     ECmdRemoveCaseFile  = 0x0B,

    53     ECmdCaseMsg         = 0x0C,

    54     ECmdSetDevId        = 0x0D,

    55     ECmdTestCompleted   = 0x0E,

    56     ECmdAtsMessage      = 0x0F,

    57     ECmdSetAttribute    = 0x10

    58     };

    59 

    60 _LIT8( KParameterDelimiter, "|" );

    61 

    62 // NOTE: Max length for error description is defined

    63 // in HtiDispatcherInterface.h (currently 118).

    64 _LIT8( KErrorStifTfNotOpen, "ERROR: STIF TF is not open" );

    65 _LIT8( KErrorOpen, "ERROR: Failed to open STIF TF" );

    66 _LIT8( KErrorAlreadyOpen, "ERROR: STIF TF is already open" );

    67 _LIT8( KErrorClose, "ERROR: Failed to close STIF TF" );

    68 _LIT8( KErrorUnknownCmd, "ERROR: Unknown STIF TF command" );

    69 _LIT8( KErrorNoCmd, "ERROR: No command given" );

    70 _LIT8( KErrorParameterMissing, "ERROR: Mandatory parameter missing" );

    71 _LIT8( KErrorParameterTooLong, "ERROR: Parameter too long" );

    72 _LIT8( KErrorTooManyParameters, "ERROR: Too many parameters" );

    73 _LIT8( KErrorNoMemory, "ERROR: Memory allocation failure" );

    74 _LIT8( KErrorLoadModule, "ERROR: Load Module failed" );

    75 _LIT8( KErrorUnloadModule, "ERROR: Unload Module failed" );

    76 _LIT8( KErrorInvalidCaseNumber, "ERROR: Invalid test case number parameter" );

    77 _LIT8( KErrorModuleNotLoaded, "ERROR: Given test module is not loaded" );

    78 _LIT8( KErrorGetTestCases, "ERROR: Failed to get test cases from module" );

    79 _LIT8( KErrorGetTestCaseInfos, "ERROR: Failed to get test case infos" );

    80 _LIT8( KErrorStartTestCase, "ERROR: Failed to start test case" );

    81 _LIT8( KErrorCancelTestCase, "ERROR: Failed to cancel test case" );

    82 _LIT8( KErrorPauseTestCase, "ERROR: Failed to pause test case" );

    83 _LIT8( KErrorResumeTestCase, "ERROR: Failed to resume test case" );

    84 _LIT8( KErrorInvalidDeviceId, "ERROR: Invalid device ID parameter" );

    85 _LIT8( KErrorAddCaseFile, "ERROR: Add Case File failed" );

    86 _LIT8( KErrorRemoveCaseFile, "ERROR: Remove Case File failed" );

    87 _LIT8( KErrorFileServer, "ERROR: Failed to connect to file server" );

    88 _LIT8( KErrorCaseFileNotFound, "ERROR: Given test case file was not found" );

    89 _LIT8( KErrorIniFileNotFound, "ERROR: Given ini-file was not found" );

    90 _LIT8( KErrorCaseMessage, "ERROR: Test case message sending failed" );

    91 _LIT8( KErrorCharConv, "ERROR: Character conversion failed" );

    92 _LIT8( KErrorInvalidAttributeId, "ERROR: Invalid attribute id parameter" );

    93 _LIT8( KErrorSetAttribute, "ERROR: Failed to set attribute" );

    94 _LIT8( KErrorUnknown, "ERROR: Unspecified error occured" );

    95 

    96 // MODULE DATA STRUCTURES

    97 

    98 // LOCAL FUNCTION PROTOTYPES

    99 

   100 // FORWARD DECLARATIONS

   101 

   102 

   103 // ============================ MEMBER FUNCTIONS ===============================

   104 

   105 // -----------------------------------------------------------------------------

   106 // CHtiStifTfIf::CHtiStifTfIf

   107 // C++ default constructor can NOT contain any code, that

   108 // might leave.

   109 // -----------------------------------------------------------------------------

   110 //

   111 CHtiStifTfIf::CHtiStifTfIf():iIsBusy( EFalse ),

   112                              iMessage( NULL ),

   113                              iErrorCode( 0 ),

   114                              iStifTfOpen( EFalse ),

   115                              iDevId( KDefaultDevId ),

   116                              iConsole( NULL )

   117     {

   118     }

   119 

   120 // -----------------------------------------------------------------------------

   121 // CHtiStifTfIf::ConstructL

   122 // Symbian 2nd phase constructor can leave.

   123 // -----------------------------------------------------------------------------

   124 //

   125 void CHtiStifTfIf::ConstructL( CHtiStifTfServicePlugin* aPlugin )

   126     {

   127     iCommandId = 0;

   128     iParameters = new (ELeave) CDesC8ArrayFlat( 5 );

   129     iPlugin = aPlugin;

   130     }

   131 

   132 // -----------------------------------------------------------------------------

   133 // CHtiStifTfIf::NewL

   134 // Two-phased constructor.

   135 // -----------------------------------------------------------------------------

   136 //

   137 CHtiStifTfIf* CHtiStifTfIf::NewL( CHtiStifTfServicePlugin* aPlugin )

   138     {

   139     CHtiStifTfIf* self = new( ELeave ) CHtiStifTfIf;

   140     CleanupStack::PushL( self );

   141     self->ConstructL( aPlugin );

   142     CleanupStack::Pop();

   143     return self;

   144     }

   145 

   146 

   147 // Destructor

   148 CHtiStifTfIf::~CHtiStifTfIf()

   149     {

   150     if ( iParameters )

   151         {

   152         iParameters->Reset();

   153         }

   154     delete iParameters;

   155     iLoadedInfos.ResetAndDestroy();

   156     iLoadedInfos.Close();

   157     delete iMessage;

   158     if ( iStifTfOpen ) Close();

   159     iPlugin = NULL;  // Not owned, so not deleted.

   160     iConsole = NULL; // Not owned, so not deleted.

   161     }

   162 

   163 

   164 // -----------------------------------------------------------------------------

   165 // CHtiStifTfIf::ProcessMessageL

   166 // Interpretes the message and calls appropriate command handling method.

   167 // -----------------------------------------------------------------------------

   168 //

   169 void CHtiStifTfIf::ProcessMessageL( const TDesC8& aMessage,

   170     THtiMessagePriority /*aPriority*/)

   171     {

   172     HTI_LOG_FUNC_IN( "CHtiStifTfIf::ProcessMessageL" );

   173     HTI_LOG_FORMAT( "Message length = %d", aMessage.Length() );

   174 

   175     if ( iIsBusy )

   176         {

   177         HTI_LOG_TEXT( "Plugin is busy - leaving" );

   178         User::Leave( KErrInUse );

   179         }

   180 

   181     iIsBusy = ETrue;

   182 

   183     if ( aMessage.Length() < 1 )

   184         {

   185         User::LeaveIfError(

   186             SendErrorResponseMsg( KErrArgument, KErrorNoCmd ) );

   187         return;

   188         }

   189 

   190     iCommandId = aMessage[0];

   191     HTI_LOG_FORMAT( "Command = %d", iCommandId );

   192 

   193     TRAPD( err, ParseParametersL( aMessage ) );

   194 

   195     if ( err == KErrNoMemory )

   196         {

   197         User::LeaveIfError( SendErrorResponseMsg( err, KErrorNoMemory ) );

   198         return;

   199         }

   200 

   201     else if ( err )

   202         {

   203         User::LeaveIfError(

   204             SendErrorResponseMsg( KErrGeneral, KErrorUnknown ) );

   205         return;

   206         }

   207 

   208     // If STIF TF is not open, any other command than OPEN returns KErrNotReady

   209     if ( !iStifTfOpen )

   210         {

   211         if ( iCommandId == ECmdOpen )

   212             {

   213             HandleOpenCmdL();

   214             return;

   215             }

   216         else

   217             {

   218             User::LeaveIfError(

   219                 SendErrorResponseMsg( KErrNotReady, KErrorStifTfNotOpen ) );

   220             return;

   221             }

   222         }

   223 

   224 

   225     // Go through the rest of the commands

   226     if ( iCommandId == ECmdLoadModule )

   227         {

   228         HandleLoadModuleCmdL();

   229         }

   230 

   231     else if ( iCommandId == ECmdUnloadModule )

   232         {

   233         HandleUnloadModuleCmdL();

   234         }

   235 

   236     else if ( iCommandId == ECmdListCases )

   237         {

   238         HandleListCasesCmdL();

   239         }

   240 

   241     else if ( iCommandId == ECmdStartCase )

   242         {

   243         HandleStartCaseCmdL();

   244         }

   245 

   246     else if ( iCommandId == ECmdCancelCase )

   247         {

   248         HandleCancelCaseCmdL();

   249         }

   250 

   251     else if ( iCommandId == ECmdPauseCase )

   252         {

   253         HandlePauseCaseCmdL();

   254         }

   255 

   256     else if ( iCommandId == ECmdResumeCase )

   257         {

   258         HandleResumeCaseCmdL();

   259         }

   260 

   261     else if ( iCommandId == ECmdAddCaseFile )

   262         {

   263         HandleAddCaseFileCmdL();

   264         }

   265 

   266     else if ( iCommandId == ECmdRemoveCaseFile )

   267         {

   268         HandleRemoveCaseFileCmdL();

   269         }

   270 

   271     else if ( iCommandId == ECmdCaseMsg )

   272         {

   273         HandleCaseMsgCmdL();

   274         }

   275 

   276     else if ( iCommandId == ECmdSetDevId )

   277         {

   278         HandleSetDevIdCmdL();

   279         }

   280 

   281     else if ( iCommandId == ECmdSetAttribute )

   282         {

   283         HandleSetAttributeCmdL();

   284         }

   285 

   286     else if ( iCommandId == ECmdClose )

   287         {

   288         HandleCloseCmdL();

   289         }

   290 

   291     else if ( iCommandId == ECmdOpen )

   292         {

   293         User::LeaveIfError(

   294             SendErrorResponseMsg( KErrArgument, KErrorAlreadyOpen ) );

   295         }

   296 

   297     else

   298         {

   299         User::LeaveIfError(

   300             SendErrorResponseMsg( KErrArgument, KErrorUnknownCmd ) );

   301         }

   302 

   303     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::ProcessMessageL" );

   304     }

   305 

   306 

   307 // -----------------------------------------------------------------------------

   308 // CHtiStifTfIf::HandleOpenCmdL

   309 // Handles opening of the STIF Test Framework.

   310 // -----------------------------------------------------------------------------

   311 //

   312 void CHtiStifTfIf::HandleOpenCmdL()

   313     {

   314     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleOpenCmdL" );

   315 

   316     TInt err = KErrNone;

   317 

   318     // OPEN command has 1 optional parameter (test framework ini-file)

   319     if ( iParameters->Count() == 0 )

   320         {

   321         err = Open();

   322         if ( err )

   323             {

   324             SendErrorResponseMsg( err, KErrorOpen );

   325             return;

   326             }

   327 

   328         iStifTfOpen = ETrue;

   329         SendResponseMsg( _L8( "OK" ) );

   330         }

   331 

   332     else if ( iParameters->Count() == 1 )

   333         {

   334         TBuf<KMaxFileName> iniFilePath;

   335         if ( (*iParameters)[0].Length() > iniFilePath.MaxLength() )

   336             {

   337             SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

   338             return;

   339             }

   340 

   341         iniFilePath.Copy( (*iParameters)[0] );

   342 

   343         RFs fsSession;

   344         err = fsSession.Connect();

   345         if ( err )

   346             {

   347             SendErrorResponseMsg( err, KErrorFileServer );

   348             return;

   349             }

   350 

   351         if ( !( BaflUtils::FileExists( fsSession, iniFilePath ) ) )

   352             {

   353             SendErrorResponseMsg( KErrNotFound, KErrorIniFileNotFound );

   354             fsSession.Close();

   355             return;

   356             }

   357 

   358         fsSession.Close();

   359 

   360         err = Open( iniFilePath );

   361 

   362         if ( err )

   363             {

   364             SendErrorResponseMsg( err, KErrorOpen );

   365             return;

   366             }

   367 

   368         // Load the test case infos of all currently loaded test

   369         // modules (modules listed in the given ini-file).

   370         TRAP( err, LoadTestCaseInfosL() );

   371         if ( err )

   372             {

   373             SendErrorResponseMsg( err, KErrorGetTestCaseInfos );

   374             return;

   375             }

   376 

   377         iStifTfOpen = ETrue;

   378         SendResponseMsg( _L8( "OK" ) );

   379         }

   380 

   381     else

   382         {

   383         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

   384         }

   385 

   386     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleOpenCmdL" );

   387     }

   388 

   389 

   390 // -----------------------------------------------------------------------------

   391 // CHtiStifTfIf::HandleCloseCmdL

   392 // Closes the STIF Test Framework.

   393 // -----------------------------------------------------------------------------

   394 //

   395 void CHtiStifTfIf::HandleCloseCmdL()

   396     {

   397     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleCloseCmdL" );

   398 

   399     TInt err = KErrNone;

   400 

   401     // CLOSE command has no parameters

   402     if ( iParameters->Count() == 0 )

   403         {

   404         err = Close();

   405         if ( err )

   406             {

   407             SendErrorResponseMsg( err, KErrorClose );

   408             return;

   409             }

   410 

   411         iStifTfOpen = EFalse;

   412         iLoadedInfos.ResetAndDestroy(); // empty the cache of test case infos

   413         SendResponseMsg( _L8( "OK" ) );

   414         }

   415 

   416     else

   417         {

   418         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

   419         }

   420 

   421     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleCloseCmdL" );

   422     }

   423 

   424 

   425 // -----------------------------------------------------------------------------

   426 // CHtiStifTfIf::HandleLoadModuleCmdL

   427 // Loads a STIF TF test module (optionally with ini-file).

   428 // Also calls the LoadTestCaseInfosL helper method to load the test case info

   429 // objects from the test module.

   430 // -----------------------------------------------------------------------------

   431 //

   432 void CHtiStifTfIf::HandleLoadModuleCmdL()

   433     {

   434     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleLoadModuleCmdL" );

   435 

   436     TInt err = KErrNone;

   437 

   438     TBuf<KMaxFileName> moduleName;

   439     TBuf<KMaxFileName> iniFilePath;

   440 

   441     // LOAD_MODULE command has 1 mandatory parameter (module name)

   442     // and 1 optional parameter (ini-file path).

   443     if ( iParameters->Count() == 0 )

   444         {

   445         SendErrorResponseMsg( KErrArgument, KErrorParameterMissing );

   446         return;

   447         }

   448 

   449     else if ( iParameters->Count() == 1 )

   450         {

   451         if ( (*iParameters)[0].Length() > moduleName.MaxLength() )

   452             {

   453             SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

   454             return;

   455             }

   456         moduleName.Copy( (*iParameters)[0] );

   457         err = AddTestModule( moduleName );

   458         }

   459 

   460     else if ( iParameters->Count() == 2 )

   461         {

   462         if ( (*iParameters)[0].Length() > moduleName.MaxLength() ||

   463              (*iParameters)[1].Length() > iniFilePath.MaxLength() )

   464             {

   465             SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

   466             return;

   467             }

   468 

   469         moduleName.Copy( (*iParameters)[0] );

   470         iniFilePath.Copy( (*iParameters)[1] );

   471 

   472         RFs fsSession;

   473         err = fsSession.Connect();

   474         if ( err )

   475             {

   476             SendErrorResponseMsg( err, KErrorFileServer );

   477             return;

   478             }

   479 

   480         if ( !( BaflUtils::FileExists( fsSession, iniFilePath ) ) )

   481             {

   482             SendErrorResponseMsg( KErrNotFound, KErrorIniFileNotFound );

   483             fsSession.Close();

   484             return;

   485             }

   486 

   487         fsSession.Close();

   488 

   489         err = AddTestModule( moduleName, iniFilePath );

   490         }

   491 

   492     else

   493         {

   494         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

   495         return;

   496         }

   497 

   498     if ( err )

   499         {

   500         HTI_LOG_FORMAT( "LoadModule: Error %d", err );

   501         SendErrorResponseMsg( err, KErrorLoadModule );

   502         }

   503 

   504     else

   505         {

   506         TRAP( err, LoadTestCaseInfosL( moduleName ) );

   507 

   508         if ( err )

   509             {

   510             HTI_LOG_FORMAT(

   511                 "LoadModule - Error from LoadTestCaseInfosL %d", err );

   512             RemoveTestModule( moduleName );

   513             SendErrorResponseMsg( err, KErrorGetTestCases );

   514             return;

   515             }

   516 

   517         // Sends the name of the loaded module as a response.

   518         SendResponseMsg( (*iParameters)[0] );

   519         }

   520 

   521     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleLoadModuleCmdL" );

   522     }

   523 

   524 

   525 // -----------------------------------------------------------------------------

   526 // CHtiStifTfIf::HandleUnloadModuleCmdL

   527 // Unloads a STIF TF test module.

   528 // Also removes and deletes the corresponding CHtiTestModuleCaseInfos object

   529 // from iLoadedInfos pointer array.

   530 // -----------------------------------------------------------------------------

   531 //

   532 void CHtiStifTfIf::HandleUnloadModuleCmdL()

   533     {

   534     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleUnloadModuleCmdL" );

   535 

   536     TInt err = KErrNone;

   537 

   538     TBuf<KMaxFileName> moduleName;

   539 

   540     // UNLOAD_MODULE command has always 1 parameter (module name).

   541     if ( iParameters->Count() == 0 )

   542         {

   543         SendErrorResponseMsg( KErrArgument, KErrorParameterMissing );

   544         return;

   545         }

   546 

   547     if ( iParameters->Count() == 1 )

   548         {

   549         if ( (*iParameters)[0].Length() > moduleName.MaxLength() )

   550             {

   551             SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

   552             return;

   553             }

   554         moduleName.Copy( (*iParameters)[0] );

   555         err = RemoveTestModule( moduleName );

   556         }

   557 

   558     else

   559         {

   560         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

   561         return;

   562         }

   563 

   564     if ( err )

   565         {

   566         HTI_LOG_FORMAT( "UnloadModule: Error %d", err );

   567         SendErrorResponseMsg( err, KErrorUnloadModule );

   568         }

   569 

   570     else

   571         {

   572         // Remove the test case infos of the unloaded module.

   573         TInt moduleIndex = IndexByModuleName( moduleName );

   574         if ( moduleIndex != KErrNotFound )

   575             {

   576             CHtiTestModuleCaseInfos* module = iLoadedInfos[moduleIndex];

   577             iLoadedInfos.Remove( moduleIndex );

   578             delete module;

   579             }

   580 

   581         // Sends the name of the unloaded module as a response.

   582         SendResponseMsg( (*iParameters)[0] );

   583         }

   584 

   585     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleUnloadModuleCmdL" );

   586     }

   587 

   588 

   589 // -----------------------------------------------------------------------------

   590 // CHtiStifTfIf::HandleListCasesCmdL

   591 // Creates a list of titles of the test cases inside the given test module.

   592 // Output is a string of test case titles separated with the | character.

   593 // -----------------------------------------------------------------------------

   594 //

   595 void CHtiStifTfIf::HandleListCasesCmdL()

   596     {

   597     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleListCasesCmdL" );

   598 

   599     TInt err = KErrNone;

   600 

   601     TBuf<KMaxFileName> moduleName;

   602     TBuf8<128> buf8;  // temporary buffer for case titles

   603 

   604     CHtiTestModuleCaseInfos* module = NULL;

   605     CTestInfo* caseInfo = NULL;

   606 

   607     // LIST_CASES command has 1 optional parameter (module name).

   608 

   609     // If no parameter given all cases of all currently loaded

   610     // modules are listed.

   611     if ( iParameters->Count() == 0 )

   612         {

   613         /*

   614         // (Re)load case infos from all loaded modules

   615         TRAP( err, LoadTestCaseInfosL() );

   616 

   617         if ( err )

   618             {

   619             HTI_LOG_FORMAT(

   620                 "ListCases - Error from LoadTestCaseInfosL %d", err );

   621             SendErrorResponseMsg( err, KErrorGetTestCaseInfos );

   622             }

   623         */

   624         CBufFlat* caseListBuf = NULL;

   625         TRAP( err, caseListBuf = CBufFlat::NewL( 128 ) );

   626         if ( err )

   627             {

   628             SendErrorResponseMsg( KErrNoMemory, KErrorNoMemory );

   629             return;

   630             }

   631 

   632         // Loop all loaded test modules

   633         TInt pos = 0;

   634         for ( TInt i = 0; i < iLoadedInfos.Count(); i++ )

   635             {

   636             module = NULL;

   637             module = iLoadedInfos[i];

   638             HTI_LOG_FORMAT( "Listing cases from module %S",

   639                 module->iModuleName );

   640 

   641             // Loop all case infos in this module

   642             for ( TInt j = 0; j < module->iTestInfos.Count(); j++ )

   643                 {

   644                 caseInfo = NULL;

   645                 caseInfo = module->iTestInfos[j];

   646 

   647                 if ( !( i == 0 && j == 0 ) )

   648                     {

   649                     buf8.Append( KParameterDelimiter );

   650                     }

   651 

   652                 buf8.Append( caseInfo->TestCaseTitle() );

   653 

   654                 TRAP( err, caseListBuf->ExpandL( pos, buf8.Length() ) );

   655                 if ( err )

   656                     {

   657                     SendErrorResponseMsg( KErrNoMemory, KErrorNoMemory );

   658                     delete caseListBuf;

   659                     return;

   660                     }

   661                 caseListBuf->Write( pos, buf8, buf8.Length() );

   662                 pos += buf8.Length();

   663                 buf8.Zero();

   664                 }

   665             }

   666 

   667         if ( caseListBuf->Size() > 0 )

   668             {

   669             TPtr8 ptr = caseListBuf->Ptr( 0 );

   670             SendResponseMsg( ptr );

   671             }

   672 

   673         else

   674             {

   675             SendResponseMsg( buf8 );

   676             }

   677 

   678         delete caseListBuf;

   679         }

   680 

   681     else if ( iParameters->Count() == 1 )

   682         {

   683         if ( (*iParameters)[0].Length() > moduleName.MaxLength() )

   684             {

   685             SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

   686             return;

   687             }

   688 

   689         moduleName.Copy( (*iParameters)[0] );

   690         TInt moduleIndex = IndexByModuleName( moduleName );

   691 

   692         if ( moduleIndex == KErrNotFound )

   693             {

   694             HTI_LOG_TEXT( "Module is not loaded" );

   695             SendErrorResponseMsg( KErrNotFound, KErrorModuleNotLoaded );

   696             return;

   697             }

   698         /*

   699         // (Re)load the case infos of given module

   700         TRAP( err, LoadTestCaseInfosL( moduleName ) );

   701         if ( err )

   702             {

   703             HTI_LOG_FORMAT(

   704                 "ListCases - Error from LoadTestCaseInfosL %d", err );

   705             SendErrorResponseMsg( err, KErrorGetTestCaseInfos );

   706             return;

   707             }

   708         */

   709         module = iLoadedInfos[moduleIndex];

   710         CBufFlat* caseListBuf = NULL;

   711 

   712         TRAP( err, caseListBuf = CBufFlat::NewL( 128 ) );

   713 

   714         if ( err )

   715             {

   716             SendErrorResponseMsg( KErrNoMemory, KErrorNoMemory );

   717             return;

   718             }

   719 

   720         TInt pos = 0;

   721         for ( TInt i = 0; i < module->iTestInfos.Count(); i++ )

   722             {

   723             caseInfo = NULL;

   724             caseInfo = module->iTestInfos[i];

   725             buf8.Copy( caseInfo->TestCaseTitle() );

   726             if ( !( i == module->iTestInfos.Count() - 1 ) )

   727                 {

   728                 buf8.Append( KParameterDelimiter );

   729                 }

   730             TRAP( err, caseListBuf->ExpandL( pos, buf8.Length() ) );

   731             if ( err )

   732                 {

   733                 SendErrorResponseMsg( KErrNoMemory, KErrorNoMemory );

   734                 delete caseListBuf;

   735                 return;

   736                 }

   737             caseListBuf->Write( pos, buf8, buf8.Length() );

   738             pos += buf8.Length();

   739             buf8.Zero();

   740             }

   741 

   742         if ( module->iTestInfos.Count() > 0 )

   743             {

   744             TPtr8 ptr = caseListBuf->Ptr( 0 );

   745             SendResponseMsg( ptr );

   746             }

   747 

   748         else

   749             {

   750             SendResponseMsg( buf8 );

   751             }

   752 

   753         delete caseListBuf;

   754         }

   755 

   756     else

   757         {

   758         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

   759         }

   760 

   761     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleListCasesCmdL" );

   762     }

   763 

   764 

   765 // -----------------------------------------------------------------------------

   766 // CHtiStifTfIf::HandleStartCaseCmdL

   767 // Starts one test case based on test module name and test case index number.

   768 // STIF TF gives an ID to the started case and that ID is sent as a response

   769 // message.

   770 // -----------------------------------------------------------------------------

   771 //

   772 void CHtiStifTfIf::HandleStartCaseCmdL()

   773     {

   774     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleStartCaseCmdL" );

   775 

   776     TInt err = KErrNone;

   777     TInt caseNumber = -1;

   778 

   779     // START_CASE command has 1 or 2 parameters.

   780     // If only one parameter given, it's the index of test case to start. The

   781     // index refers to the list of test cases of all currently loaded modules.

   782     // If two parameters given, then the first one is the module name and

   783     // second is the test case index number inside the given module,

   784 

   785     if ( iParameters->Count() == 0 )

   786         {

   787         SendErrorResponseMsg( KErrArgument, KErrorParameterMissing );

   788         return;

   789         }

   790 

   791     else if ( iParameters->Count() == 1 )

   792         {

   793         TLex8 lex( (*iParameters)[0] );

   794         err = lex.Val( caseNumber );

   795         if ( err )

   796             {

   797             SendErrorResponseMsg( err, KErrorInvalidCaseNumber );

   798             return;

   799             }

   800 

   801         CTestInfo* caseInfo = NULL;

   802         TRAP( err, caseInfo = GetCaseInfoL( caseNumber ) );

   803 

   804         if ( err )

   805             {

   806             SendErrorResponseMsg( err, KErrorInvalidCaseNumber );

   807             return;

   808             }

   809 

   810         TInt caseId = -1;

   811 

   812         err = StartTestCase( caseId, *caseInfo );

   813 

   814         if ( err )

   815             {

   816             SendErrorResponseMsg( err, KErrorStartTestCase );

   817             return;

   818             }

   819 

   820         TBuf8<32> msg;

   821         msg.AppendNum( caseId );

   822         SendResponseMsg( msg );

   823         }

   824 

   825     else if ( iParameters->Count() == 2 )

   826         {

   827         TBuf<KMaxFileName> moduleName;

   828         if ( (*iParameters)[0].Length() > moduleName.MaxLength() )

   829             {

   830             SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

   831             return;

   832             }

   833 

   834         moduleName.Copy( (*iParameters)[0] );

   835         TLex8 lex( (*iParameters)[1] );

   836         err = lex.Val( caseNumber );

   837         if ( err )

   838             {

   839             SendErrorResponseMsg( err, KErrorInvalidCaseNumber );

   840             return;

   841             }

   842 

   843         TInt moduleIndex = IndexByModuleName( moduleName );

   844 

   845         if ( moduleIndex == KErrNotFound )

   846             {

   847             // We don't have case infos of given module loaded - try to

   848             // load them.

   849             TRAP( err, LoadTestCaseInfosL( moduleName ) );

   850             if ( err )

   851                 {

   852                 HTI_LOG_FORMAT(

   853                     "StartCase - Error from LoadTestCaseInfosL %d", err );

   854                 SendErrorResponseMsg( err, KErrorModuleNotLoaded );

   855                 return;

   856                 }

   857             // Now there should be the module added - get its index

   858             moduleIndex = IndexByModuleName( moduleName );

   859             }

   860 

   861         CHtiTestModuleCaseInfos* module = iLoadedInfos[moduleIndex];

   862 

   863         if ( caseNumber < 0 ||

   864              caseNumber >= module->iTestInfos.Count() ||

   865              module->iTestInfos.Count() == 0 )

   866             {

   867             SendErrorResponseMsg( KErrArgument, KErrorInvalidCaseNumber );

   868             return;

   869             }

   870 

   871         CTestInfo* caseInfo = module->iTestInfos[caseNumber];

   872         TInt caseId = -1;

   873 

   874         err = StartTestCase( caseId, *caseInfo );

   875 

   876         if ( err )

   877             {

   878             SendErrorResponseMsg( err, KErrorStartTestCase );

   879             return;

   880             }

   881 

   882         TBuf8<32> msg;

   883         msg.AppendNum( caseId );

   884         SendResponseMsg( msg );

   885         }

   886 

   887     else

   888         {

   889         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

   890         }

   891 

   892     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleStartCaseCmdL" );

   893     }

   894 

   895 

   896 // -----------------------------------------------------------------------------

   897 // CHtiStifTfIf::HandleCancelCaseCmdL

   898 // Cancels test case execution based on test case ID.

   899 // -----------------------------------------------------------------------------

   900 //

   901 void CHtiStifTfIf::HandleCancelCaseCmdL()

   902     {

   903     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleCancelCaseCmdL" );

   904 

   905     TInt err = KErrNone;

   906 

   907     // CANCEL_CASE command always has 1 parameter (test case id).

   908     if ( iParameters->Count() == 0 )

   909         {

   910         SendErrorResponseMsg( KErrArgument, KErrorParameterMissing );

   911         return;

   912         }

   913 

   914     else if ( iParameters->Count() == 1 )

   915         {

   916         TInt caseId = -1;

   917         TLex8 lex( (*iParameters)[0] );

   918         err = lex.Val( caseId );

   919 

   920         if ( err )

   921             {

   922             SendErrorResponseMsg( err, KErrorInvalidCaseNumber );

   923             return;

   924             }

   925 

   926         err = CancelTestCase( caseId );

   927 

   928         if ( err )

   929             {

   930             SendErrorResponseMsg( err, KErrorCancelTestCase );

   931             }

   932 

   933         else

   934             {

   935             SendResponseMsg( _L8( "OK" ) );

   936             }

   937         }

   938 

   939     else

   940         {

   941         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

   942         }

   943 

   944     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleCancelCaseCmdL" );

   945     }

   946 

   947 

   948 // -----------------------------------------------------------------------------

   949 // CHtiStifTfIf::HandlePauseCaseCmdL

   950 // Pauses test case execution based on test case ID.

   951 // -----------------------------------------------------------------------------

   952 //

   953 void CHtiStifTfIf::HandlePauseCaseCmdL()

   954     {

   955     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandlePauseCaseCmdL" );

   956 

   957     TInt err = KErrNone;

   958 

   959     // PAUSE_CASE command always has 1 parameter (test case id).

   960     if ( iParameters->Count() == 0 )

   961         {

   962         SendErrorResponseMsg( KErrArgument, KErrorParameterMissing );

   963         return;

   964         }

   965 

   966     else if ( iParameters->Count() == 1 )

   967         {

   968         TInt caseId = -1;

   969         TLex8 lex( (*iParameters)[0] );

   970         err = lex.Val( caseId );

   971 

   972         if ( err )

   973             {

   974             SendErrorResponseMsg( err, KErrorInvalidCaseNumber );

   975             return;

   976             }

   977 

   978         err = PauseTestCase( caseId );

   979 

   980         if ( err )

   981             {

   982             SendErrorResponseMsg( err, KErrorPauseTestCase );

   983             }

   984 

   985         else

   986             {

   987             SendResponseMsg( _L8( "OK" ) );

   988             }

   989         }

   990 

   991     else

   992         {

   993         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

   994         }

   995 

   996     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandlePauseCaseCmdL" );

   997     }

   998 

   999 

  1000 // -----------------------------------------------------------------------------

  1001 // CHtiStifTfIf::HandleResumeCaseCmdL

  1002 // Resumes execution of a paused test case based on test case ID.

  1003 // -----------------------------------------------------------------------------

  1004 //

  1005 void CHtiStifTfIf::HandleResumeCaseCmdL()

  1006     {

  1007     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleResumeCaseCmdL" );

  1008 

  1009     TInt err = KErrNone;

  1010 

  1011     // RESUME_CASE command always has 1 parameter (test case id).

  1012     if ( iParameters->Count() == 0 )

  1013         {

  1014         SendErrorResponseMsg( KErrArgument, KErrorParameterMissing );

  1015         return;

  1016         }

  1017 

  1018     else if ( iParameters->Count() == 1 )

  1019         {

  1020         TInt caseId = -1;

  1021         TLex8 lex( (*iParameters)[0] );

  1022         err = lex.Val( caseId );

  1023 

  1024         if ( err )

  1025             {

  1026             SendErrorResponseMsg( err, KErrorInvalidCaseNumber );

  1027             return;

  1028             }

  1029 

  1030         err = ResumeTestCase( caseId );

  1031 

  1032         if ( err )

  1033             {

  1034             SendErrorResponseMsg( err, KErrorResumeTestCase );

  1035             }

  1036 

  1037         else

  1038             {

  1039             SendResponseMsg( _L8( "OK" ) );

  1040             }

  1041         }

  1042 

  1043     else

  1044         {

  1045         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

  1046         }

  1047 

  1048     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleResumeCaseCmdL" );

  1049     }

  1050 

  1051 

  1052 // -----------------------------------------------------------------------------

  1053 // CHtiStifTfIf::HandleAddCaseFileCmdL

  1054 // Adds a test case file to an earlier loaded test module.

  1055 // Checks that the module is loaded and that the given test case file exists.

  1056 // -----------------------------------------------------------------------------

  1057 //

  1058 void CHtiStifTfIf::HandleAddCaseFileCmdL()

  1059     {

  1060     HTI_LOG_FUNC_IN( "CHtiStifTfIf::HandleAddCaseFileCmdL" );

  1061 

  1062     TInt err = KErrNone;

  1063 

  1064     TBuf<KMaxFileName> moduleName;

  1065     TBuf<KMaxFileName> caseFilePath;

  1066 

  1067     // ADD_CASE_FILE command always has 2 mandatory parameters (module name

  1068     // and test case file path).

  1069     if ( iParameters->Count() == 0 || iParameters->Count() == 1 )

  1070         {

  1071         SendErrorResponseMsg( KErrArgument, KErrorParameterMissing );

  1072         return;

  1073         }

  1074 

  1075     else if ( iParameters->Count() == 2 )

  1076         {

  1077         if ( (*iParameters)[0].Length() > moduleName.MaxLength() ||

  1078              (*iParameters)[1].Length() > caseFilePath.MaxLength() )

  1079             {

  1080             SendErrorResponseMsg( KErrArgument, KErrorParameterTooLong );

  1081             return;

  1082             }

  1083 

  1084         moduleName.Copy( (*iParameters)[0] );

  1085         caseFilePath.Copy( (*iParameters)[1] );

  1086 

  1087         RFs fsSession;

  1088         err = fsSession.Connect();

  1089         if ( err )

  1090             {

  1091             SendErrorResponseMsg( err, KErrorFileServer );

  1092             return;

  1093             }

  1094 

  1095         if ( !( BaflUtils::FileExists( fsSession, caseFilePath ) ) )

  1096             {

  1097             SendErrorResponseMsg( KErrNotFound, KErrorCaseFileNotFound );

  1098             fsSession.Close();

  1099             return;

  1100             }

  1101 

  1102         fsSession.Close();

  1103 

  1104         err = AddTestCaseFile( moduleName, caseFilePath );

  1105 

  1106         if ( err )

  1107             {

  1108             SendErrorResponseMsg( err, KErrorAddCaseFile );

  1109             return;

  1110             }

  1111 

  1112         // Test case file has been added - update test case infos

  1113         TRAP( err, LoadTestCaseInfosL( moduleName ) );

  1114 

  1115         if ( err )

  1116             {

  1117             HTI_LOG_FORMAT(

  1118                 "AddCaseFile - Error from LoadTestCaseInfosL %d", err );

  1119             SendErrorResponseMsg( err, KErrorGetTestCases );

  1120             return;

  1121             }

  1122 

  1123         SendResponseMsg( _L8( "OK" ) );

  1124         }

  1125 

  1126     else

  1127         {

  1128         SendErrorResponseMsg( KErrArgument, KErrorTooManyParameters );

  1129         }

  1130 

  1131     HTI_LOG_FUNC_OUT( "CHtiStifTfIf::HandleAddCaseFileCmdL" );

  1132     }

  1133 

  1134