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 file contains TestModuleIf implementation.

    15 *

    16 */

    17 

    18 // INCLUDE FILES

    19 #include <e32svr.h>

    20 #include "StifTFwIfProt.h"

    21 #include "StifTestInterface.h"

    22 #include "TestServerModuleIf.h"

    23 #include "StifTestModule.h"

    24 #include "TestThreadContainer.h"

    25 #include "STIFMeasurement.h"

    26 

    27 // EXTERNAL DATA STRUCTURES

    28 // None

    29 

    30 // EXTERNAL FUNCTION PROTOTYPES  

    31 // None

    32 

    33 // CONSTANTS

    34 // None

    35 

    36 // MACROS

    37 // Debugging is enabled with next define

    38 #define __TRACING_ENABLED

    39 #ifdef __TRACING_ENABLED

    40 #define __RDEBUG(p) RDebug::Print p 

    41 #else

    42 #define __RDEBUG(p)

    43 #endif

    44 

    45 // LOCAL CONSTANTS AND MACROS

    46 // None

    47 

    48 // MODULE DATA STRUCTURES

    49 // None

    50 

    51 // LOCAL FUNCTION PROTOTYPES

    52 // None

    53 

    54 // FORWARD DECLARATIONS

    55 // None

    56 

    57 // ==================== LOCAL FUNCTIONS =======================================

    58 

    59 /*

    60 -------------------------------------------------------------------------------

    61 

    62     DESCRIPTION

    63 

    64     TDesOverflowHandler class contains a simple overflow handler implementation.

    65 

    66 -------------------------------------------------------------------------------

    67 */

    68 class TDesOverflowHandler : public TDes16Overflow

    69     {

    70     public:

    71         TDesOverflowHandler( CTestModuleIf* aModuleIf, 

    72                              const TInt aPriority, 

    73                              const TDesC& aDefinition)

    74             {

    75             iModuleIf = aModuleIf;

    76             iPriority = aPriority;

    77             iDefinition = aDefinition;

    78             }

    79 

    80         void Overflow(TDes16& /*aDes*/ )

    81             { 

    82             }

    83     

    84         CTestModuleIf* iModuleIf;

    85         TInt iPriority;

    86         TStifInfoName iDefinition;

    87     };

    88 

    89 /*

    90 -------------------------------------------------------------------------------

    91 

    92     DESCRIPTION

    93 

    94     This module contains the implementation of CTestModuleIf class 

    95     member functions.

    96 

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

    98 */

    99 

   100 // ================= MEMBER FUNCTIONS =========================================

   101 

   102 /*

   103 -------------------------------------------------------------------------------

   104 

   105     Class: CTestModuleIf

   106 

   107     Method: CTestModuleIf

   108 

   109     Description: Default constructor

   110 

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

   112     might leave.

   113     

   114     Parameters: None

   115     

   116     Return Values: None

   117     

   118     Errors/Exceptions: None

   119     

   120     Status: Approved

   121     

   122 -------------------------------------------------------------------------------

   123 */

   124 CTestModuleIf::CTestModuleIf( CTestThreadContainer* aTestExecution ) :

   125     iTestExecution( aTestExecution )

   126     {

   127     }

   128 

   129 /*

   130 -------------------------------------------------------------------------------

   131 

   132     Class: CTestModuleIf

   133 

   134     Method: ConstructL

   135 

   136     Description: Symbian OS second phase constructor

   137 

   138     Symbian OS default constructor can leave.

   139 

   140     Parameters: CTestExecution* aTestExecution: in: Pointer to TestExecution

   141                 CTestModuleBase* aTestModule: in: Pointer to TestModule

   142     

   143     Return Values: None

   144     

   145     Errors/Exceptions: None

   146     

   147     Status: Approved

   148     

   149 -------------------------------------------------------------------------------

   150 */

   151 void CTestModuleIf::ConstructL( CTestModuleBase* aTestModule )

   152     {

   153 

   154     if ( aTestModule->iTestModuleIf != NULL)

   155         {

   156         delete aTestModule->iTestModuleIf;

   157         aTestModule->iTestModuleIf = NULL;

   158         }

   159     aTestModule->iTestModuleIf = this; 

   160 

   161     iIsRebootReady = EFalse;

   162     iStoreStateCounter = 0;

   163 

   164     // Used to "resets" iTestCaseResults array

   165     iAllowTestCaseResultsCount = 0;

   166 

   167     }

   168 

   169 /*

   170 -------------------------------------------------------------------------------

   171 

   172     Class: CTestModuleIf

   173 

   174     Method: NewL

   175 

   176     Description: Two-phased constructor.

   177 

   178     Parameters: CTestExecution* aTestExecution: in: Pointer to TestExecution

   179                 CTestModuleBase* aTestModule: in: Pointer to TestModule

   180     

   181     Return Values: CTestModuleIf object.

   182 

   183     Errors/Exceptions: Leaves if memory allocation fails

   184                        Leaves if ConstructL leaves

   185 

   186     Status: Approved

   187     

   188 -------------------------------------------------------------------------------

   189 */

   190 EXPORT_C CTestModuleIf* CTestModuleIf::NewL( CTestThreadContainer* aExecutionSession, 

   191                                              CTestModuleBase* aTestModule )

   192     {

   193 

   194     CTestModuleIf* self = 

   195         new (ELeave) CTestModuleIf( aExecutionSession );

   196     

   197     CleanupStack::PushL( self );

   198     self->ConstructL( aTestModule );

   199 

   200     CleanupStack::Pop();

   201 

   202     return self;

   203 

   204     }

   205 

   206 /*

   207 -------------------------------------------------------------------------------

   208 

   209     Class: CTestModuleIf

   210 

   211     Method: ~CTestModuleIf

   212 

   213     Description: Destructor

   214     

   215     Parameters: None

   216     

   217     Return Values: None

   218 

   219     Errors/Exceptions: None

   220     

   221     Status: Approved

   222     

   223 -------------------------------------------------------------------------------

   224 */    

   225 CTestModuleIf::~CTestModuleIf()

   226     {

   227     iTestExecution = NULL;

   228 

   229     // Used to "resets" iTestCaseResults array

   230     iAllowTestCaseResultsCount = 0;

   231 

   232     }

   233 

   234 /*

   235 -------------------------------------------------------------------------------

   236 

   237     Class: CTestModuleIf

   238 

   239     Method: Printf

   240 

   241     Description: Printing

   242 

   243     Printf is used to provide different information up to the UI 

   244     that can be then printed e.g. to the Console Screen. 

   245     The priority can be used in the UI to decide if the information 

   246     received from the Test DLL will be discarded or not in 

   247     the different performance situations. The priority is also 

   248     used in the Test DLL server and in the Test Engine to queue 

   249     the Printf responses.

   250     This method is implemented in Test DLL Server and the Test DLL 

   251     can call it to provide printable information to the UI.

   252 

   253     Parameters:  const TInt aPriority: in: 

   254                     Importance of the returned information

   255                  const TDesC& aDefinition: in: 

   256                     Definition of data to be printed 

   257                  TRefByValue<const TDesC> aFmt: in: Printed data

   258     

   259     Return Values: None

   260     

   261     Errors/Exceptions: None

   262     

   263     Status: Approved

   264     

   265 -------------------------------------------------------------------------------

   266 */

   267 EXPORT_C void CTestModuleIf::Printf( const TInt aPriority, 

   268                                      const TDesC& aDefinition, 

   269                                      TRefByValue<const TDesC> aFmt,

   270                                      ... 

   271                                    )

   272     {           

   273 

   274     if( !IsServerAlive() )

   275         {

   276         return;

   277         }

   278 

   279     VA_LIST list;

   280     VA_START(list,aFmt);

   281     TName aBuf;

   282 

   283     // Cut the description length

   284     TInt len = aDefinition.Length();

   285     if ( len > KMaxInfoName )

   286         {

   287         len = KMaxInfoName;

   288         }

   289 

   290     TStifInfoName shortDescription = aDefinition.Left(len);

   291 

   292     // Create overflow handler

   293     TDesOverflowHandler overFlowHandler (this, aPriority, shortDescription);

   294 

   295     // Parse parameters

   296     aBuf.AppendFormatList(aFmt,list, &overFlowHandler);        

   297 

   298     // Print

   299     iTestExecution->DoNotifyPrint( aPriority, shortDescription, aBuf );

   300 

   301     }

   302 

   303 /*

   304 -------------------------------------------------------------------------------

   305 

   306     Class: CTestModuleIf

   307 

   308     Method: Event

   309 

   310     Description: Event control.

   311 

   312     Event function is used to control and use the event system. 

   313     TEventIf &aEvent encapsulates the request type and 

   314     the event name, see StifTestEventInterface.h for more information.

   315     This method is implemented in Test DLL Server and the Test DLL 

   316     can call it to control the event system.

   317   

   318     Parameters: TEventIf& aEvent: in: Event command

   319     

   320     Return Values: Symbian OS error code.

   321 

   322     Errors/Exceptions: None

   323 

   324     Status: Approved

   325     

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

   327 */      

   328 EXPORT_C TInt CTestModuleIf::Event( TEventIf& aEvent )

   329     {

   330 

   331     if( !IsServerAlive() )

   332         {

   333         return KErrGeneral;

   334         }

   335 

   336     // All event commands are handled in testserver and testengine

   337     return iTestExecution->DoNotifyEvent( aEvent );

   338     

   339     }

   340 

   341 /*

   342 -------------------------------------------------------------------------------

   343 

   344     Class: CTestModuleIf

   345 

   346     Method: Event

   347 

   348     Description: Event control.

   349 

   350     Asynchronous version of event control function.

   351     It is used to control and use the event system asynchronously. 

   352     TEventIf &aEvent encapsulates the request type and 

   353     the event number, see StifTestEventInterface.h for more information.

   354     This method is implemented in Test DLL Server and the Test DLL 

   355     can call it to control the event system.

   356   

   357     Parameters: TEventIf& aEvent: in: Event command

   358                 TRequestStatus& aStatus: in: Request status parameter

   359 

   360     Return Values: None. 

   361     

   362     Errors/Exceptions: None

   363 

   364     Status: Approved

   365     

   366 -------------------------------------------------------------------------------

   367 */      

   368 EXPORT_C void CTestModuleIf::Event( TEventIf& aEvent, TRequestStatus& aStatus )

   369     {

   370     TInt ret = KErrNone;

   371 

   372     if( !IsServerAlive() )

   373         {

   374         __RDEBUG( (_L("iTestExecution not initialised")));

   375         ret = KErrGeneral;

   376         }

   377     else

   378         {        

   379         aStatus = KRequestPending;

   380 

   381         // All event commands are handled in testserver and testengine

   382         ret = iTestExecution->DoNotifyEvent( aEvent, &aStatus );

   383         }

   384     if( ret != KErrNone )

   385         {

   386         TRequestStatus* rs = &aStatus;

   387         User::RequestComplete( rs, ret );

   388         }

   389     

   390     }

   391     

   392 /*

   393 -------------------------------------------------------------------------------

   394 

   395     Class: CTestModuleIf

   396 

   397     Method: CancelEvent

   398 

   399     Description: Cancel asynchronous event control call.

   400   

   401     Parameters: TEventIf& aEvent: in: Event command to be cancelled.

   402                 const TRequestStatus* aStatus: in: 

   403                     Pointer to TRequestStatus parameter that is cancelled

   404 

   405     Return Values: Symbian OS error code.

   406     

   407     Errors/Exceptions: None

   408     

   409     Status: Approved

   410     

   411 -------------------------------------------------------------------------------

   412 */      

   413 EXPORT_C TInt CTestModuleIf::CancelEvent( TEventIf& aEvent,

   414                                           TRequestStatus* aStatus )

   415     {

   416      if( !IsServerAlive() )

   417         {

   418         __RDEBUG( (_L("iTestExecution not initialised")));

   419         return KErrGeneral;

   420         }

   421 

   422     // All event commands are handled in testserver and testengine

   423     iTestExecution->CancelEvent( aEvent, aStatus );

   424     

   425     return KErrNone;

   426     

   427     }

   428 

   429 

   430 /*

   431 -------------------------------------------------------------------------------

   432 

   433     Class: CTestModuleIf

   434 

   435     Method: SetExitReason

   436 

   437     Description: Set exit reason

   438   

   439     Parameters: const TExitReason aExitReason in: Exit reason

   440                 const TInt aExitCode in: Exit code

   441 

   442     Return Values: None

   443     

   444     Errors/Exceptions: None

   445     

   446     Status: Proposal

   447     

   448 -------------------------------------------------------------------------------

   449 */      

   450 EXPORT_C void CTestModuleIf::SetExitReason( const CTestModuleIf::TExitReason aExitReason, 

   451                                             const TInt aExitCode )

   452         

   453     {

   454 

   455      if( !IsServerAlive() )

   456         {

   457         __RDEBUG( (_L("iTestExecution not initialised")));

   458         return;

   459         }

   460     

   461     iTestExecution->SetExitReason( aExitReason, aExitCode );

   462     

   463     }

   464 

   465 /*

   466 -------------------------------------------------------------------------------

   467 

   468     Class: CTestModuleIf

   469 

   470     Method: RemoteSend

   471 

   472     Description: RemoteSend is used to send control protocol messages to slaves

   473         (e.g. another phone, call box, ...). 

   474     

   475     Parameters:  const TDesC& aRemoteMsg: in: 

   476                     Remote command protocol message 

   477                  

   478     Return Values: None

   479     

   480     Errors/Exceptions: None

   481     

   482     Status: Proposal

   483     

   484 -------------------------------------------------------------------------------

   485 */

   486 EXPORT_C TInt CTestModuleIf::RemoteSend( const TDesC& aRemoteMsg )

   487     {           

   488 

   489     if( !IsServerAlive() )

   490         {

   491         __RDEBUG( ( _L("iTestExecution not initialised") ) );

   492         return KErrNotReady;

   493         }

   494 

   495     TParams params;

   496     params.aRemoteMsgConstRef = &aRemoteMsg;

   497 

   498     TRequestStatus status = KRequestPending; 

   499 

   500     // Forward

   501     iTestExecution->DoRemoteReceive( EStifCmdSend, params, 

   502                                      aRemoteMsg.Length(), status );

   503     

   504     User::WaitForRequest( status );

   505 

   506     return status.Int();

   507 

   508     }

   509     

   510 /*

   511 -------------------------------------------------------------------------------

   512 

   513     Class: CTestModuleIf

   514 

   515     Method: RemoteReceive

   516 

   517     Description: RemoteReceive is used to receive control protocol messages to 

   518         slaves (e.g. another phone, call box, ...). 

   519     

   520     Parameters:  const TDesC& aRemoteMsg: in: 

   521                     Remote command protocol message 

   522                  TRequestStatus& aStatus: in: Request status parameter

   523 

   524     Return Values: None

   525     

   526     Errors/Exceptions: None

   527     

   528     Status: Proposal

   529     

   530 -------------------------------------------------------------------------------

   531 */

   532 EXPORT_C void CTestModuleIf::RemoteReceive( TDes& aRemoteMsg, 

   533                                             TRequestStatus& aStatus )

   534     {           

   535     aStatus = KRequestPending;

   536     if( !IsServerAlive() )

   537         {

   538         __RDEBUG( ( _L("iTestExecution not initialised") ) );

   539         TRequestStatus* rs = &aStatus;

   540         User::RequestComplete( rs, KErrNotReady );

   541         }

   542 

   543     TParams params;

   544     params.aRemoteMsgRef = &aRemoteMsg;

   545 

   546     iTestExecution->DoRemoteReceive( EStifCmdReceive, params, 

   547                                      aRemoteMsg.Length(), aStatus );

   548 

   549     }

   550     

   551 /*

   552 -------------------------------------------------------------------------------

   553 

   554     Class: CTestModuleIf

   555 

   556     Method: RemoteReceiveCancel

   557 

   558     Description: RemoteReceiveCancel is used to cancel RemoteReceive.

   559      

   560     Parameters:  None

   561     

   562     Return Values: None

   563     

   564     Errors/Exceptions: None

   565     

   566     Status: Proposal

   567     

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

   569 */

   570 EXPORT_C void CTestModuleIf::RemoteReceiveCancel()

   571     {           

   572     if( !IsServerAlive() )

   573         {

   574         __RDEBUG( ( _L("iTestExecution not initialised") ) );

   575         return;

   576         }

   577 

   578     // Forward

   579     iTestExecution->DoRemoteReceiveCancel();

   580 

   581     }

   582 

   583 /*

   584 -------------------------------------------------------------------------------

   585 

   586     Class: CTestModuleIf

   587 

   588     Method: Reboot

   589 

   590     Description: Start a reboot operation.

   591 

   592     Parameters: TInt aType: in: Reboot type

   593 

   594     Return Values: TInt: Symbian OS error code.

   595 

   596     Errors/Exceptions: KErrNotReady returned if iTestExecution is NULL.

   597                        KErrNotReady returned if reboot not allowed(Store state

   598                        not called).

   599 

   600     Status: Proposal

   601 

   602 -------------------------------------------------------------------------------

   603 */

   604 EXPORT_C TInt CTestModuleIf::Reboot( TInt aType )

   605     {           

   606     if ( !IsServerAlive() )

   607         {

   608         __RDEBUG( ( _L( "iTestExecution not initialised" ) ) );

   609         return KErrNotReady;

   610         }

   611     if( !iIsRebootReady )

   612         {

   613         __RDEBUG( ( _L( "Reboot operation not ready" ) ) );

   614         return KErrNotReady;

   615         }

   616      

   617 /*    switch( aType )

   618         {

   619         case EDefaultReset:

   620             __RDEBUG( ( _L( "Reboot, type default" )) );

   621             break;

   622         case EKernelReset:

   623             __RDEBUG( ( _L( "Reboot, type KernelReset" )) );

   624             break;

   625         case EDeviceReset0:

   626             __RDEBUG( ( _L( "Reboot, type Reset 0" )) );

   627             break;

   628         case EDeviceReset1:

   629             __RDEBUG( ( _L( "Reboot, type Reset 1" )) );

   630             break;

   631         case EDeviceReset2:

   632             __RDEBUG( ( _L( "Reboot, type Reset 2" )) );

   633             break;

   634         case EDeviceReset3:

   635             __RDEBUG( ( _L( "Reboot, type Reset 3" )) );

   636             break;

   637         case EDeviceReset4:

   638             __RDEBUG( ( _L( "Reboot, type Reset 4" )) );

   639             break;

   640         case EDeviceReset5:

   641             __RDEBUG( ( _L( "Reboot, type Reset 5" )) );

   642             break;

   643         default:

   644             __RDEBUG( ( _L( "Reboot type %d not supported" ), aType ) );

   645             return KErrNotSupported;    

   646         }

   647 */

   648 

   649     TParams params;

   650     TRebootParams rebootParams;

   651     

   652     params.aRebootType = &rebootParams;

   653     rebootParams.aType = ( TRebootType )aType;

   654     

   655     TRequestStatus status = KRequestPending; 

   656 

   657     // Forward

   658     iTestExecution->DoRemoteReceive( EStifCmdReboot, params, sizeof( aType ), status );

   659     

   660     User::WaitForRequest( status );

   661 

   662     return status.Int();

   663     

   664     }

   665 

   666 /*

   667 -------------------------------------------------------------------------------

   668 

   669     Class: CTestModuleIf

   670 

   671     Method: StoreState

   672 

   673     Description: Stores the current state before reboot.

   674 

   675     Parameters: TInt aCode: in: Reboot releated integer value.

   676                 TName& aName: in: Reboot related string value.

   677 

   678     Return Values: TInt: Symbian OS error code.

   679 

   680     Errors/Exceptions: KErrNotReady returned if iTestExecution is NULL.

   681                        KErrOverflow returned if aName length is over TName.

   682                        KErrInUse returned if method is called more than once.

   683 

   684     Status: Proposal

   685 

   686 -------------------------------------------------------------------------------

   687 */

   688 EXPORT_C TInt CTestModuleIf::StoreState( TInt aCode, TName& aName )

   689     {

   690     iStoreStateCounter++;   // Store state counter

   691 

   692     if ( !IsServerAlive() )

   693         {

   694         __RDEBUG( ( _L( "iTestExecution not initialised" ) ) );

   695         return KErrNotReady;

   696         }

   697     // Check aName length

   698     if ( aName.Length() > KMaxName )

   699         {

   700         __RDEBUG( ( _L( "CTestModuleIf::StoreState(): aName length is not valid" ) ) );

   701         return KErrOverflow;

   702         }

   703     // Only one store state call may be done

   704     if( iStoreStateCounter > 1 )

   705         {

   706         __RDEBUG( ( _L( "Store state allready called" ) ) );

   707         return KErrInUse;

   708         }

   709 

   710     TParams params;

   711     TRebootStateParams rebootStateParams;

   712     params.aRebootState = &rebootStateParams;

   713     rebootStateParams.aCode = aCode;

   714     rebootStateParams.aName = aName;

   715 

   716     TRequestStatus status = KRequestPending; 

   717 

   718     // Forward

   719     iTestExecution->DoRemoteReceive( EStifCmdStoreState, params,

   720                                      sizeof( TRebootStateParams), status );

   721     

   722     User::WaitForRequest( status );

   723 

   724     // If store state is done successfully reboot operation is allowed

   725     if( status.Int() == KErrNone )

   726         {

   727         iIsRebootReady = ETrue;

   728         }

   729 

   730     return status.Int();

   731 

   732     }

   733 

   734 /*

   735 -------------------------------------------------------------------------------

   736 

   737     Class: CTestModuleIf

   738 

   739     Method: GetStoredState

   740 

   741     Description: Get saved store information after the reboot.

   742 

   743     Parameters: TInt aCode: inout: Get reboot releated integer value.

   744                 TName& aName: inout: Get reboot related string value.

   745 

   746     Return Values: TInt: Symbian OS error code.

   747 

   748     Errors/Exceptions: KErrNotReady returned if iTestExecution is NULL.

   749 

   750     Status: Proposal

   751 

   752 -------------------------------------------------------------------------------

   753 */

   754 EXPORT_C TInt CTestModuleIf::GetStoredState( TInt& aCode, TName& aName )

   755     {           

   756     if( !IsServerAlive() )

   757         {

   758         __RDEBUG( ( _L( "iTestExecution not initialised" ) ) );

   759         return KErrNotReady;

   760         }

   761 

   762     TInt code;

   763     TName name;

   764     

   765     TParams params;

   766     TGetRebootStoredParamsRef getRebootStoredParamsRef( code, name );

   767     

   768     params.aRebootStoredRef = &getRebootStoredParamsRef;

   769 

   770     TRequestStatus status = KRequestPending; 

   771 

   772     // Forward

   773     iTestExecution->DoRemoteReceive( EStifCmdGetStoredState, params,

   774                                      sizeof( TRebootStateParams), status );

   775     

   776     User::WaitForRequest( status );

   777 

   778     // Return results if getting state is done without error

   779     if(status.Int() == KErrNone)

   780         {

   781         aCode = code;

   782         aName = name;

   783         }

   784 

   785     return status.Int();

   786 

   787     }

   788 

   789 /*

   790 -------------------------------------------------------------------------------

   791 

   792     Class: CTestModuleIf

   793 

   794     Method: SetBehavior

   795 

   796     Description: Set test case behavior.

   797 

   798     Parameters: TInt aCode: inout: Get reboot releated integer value.

   799                 TName& aName: inout: Get reboot related string value.

   800 

   801     Return Values: TInt: Symbian OS error code.

   802 

   803     Errors/Exceptions: KErrNotReady returned if iTestExecution is NULL.

   804 

   805     Status: Proposal

   806 

   807 -------------------------------------------------------------------------------

   808 */

   809 EXPORT_C TInt CTestModuleIf::SetBehavior( TTestBehavior aType, TAny* aPtr )

   810     {         

   811     

   812     if( !IsServerAlive() )

   813         {

   814         return KErrGeneral;

   815         }

   816 

   817     // All event commands are handled in testserver and testengine

   818     return iTestExecution->SetBehavior( aType, aPtr );

   819     

   820     }

   821 

   822 /*

   823 -------------------------------------------------------------------------------

   824 

   825     Class: CTestModuleIf

   826 

   827     Method: StifMacroError

   828 

   829     Description: STIF TF's macros. Saves information for later use.

   830 

   831     Parameters: TInt aMacroType: in: Macro type(0:TL, 1:T1L, 2:T2L, etc.)

   832                 const TText8* aFile: in: Uses __FILE__ macro and this includes

   833                 path and file name. Maximun length for this is

   834                 KStifMacroMaxFile. If length is more then cutted from left.

   835                 char* aFunction: in: Uses __FUNCTION__ macro and this includes

   836                 function name. Maximun length for this is

   837                 KStifMacroMaxFunction. If length is more then cutted from

   838                 rigth.

   839                 TInt aLine: in: Uses __LINE__ macro and includes line number.

   840                 TInt aResult: in: Result from called operations.

   841                 TInt aExpected1: in: Users expected result.

   842                 TInt aExpected2: in: Users expected result.

   843                 TInt aExpected3: in: Users expected result.

   844                 TInt aExpected4: in: Users expected result.

   845                 TInt aExpected5: in: Users expected result.

   846 

   847     Return Values: Symbian OS error code.

   848 

   849     Errors/Exceptions: None

   850 

   851     Status: Proposal

   852 

   853 -------------------------------------------------------------------------------

   854 */

   855 EXPORT_C TInt CTestModuleIf::StifMacroError( TInt aMacroType, 

   856                                              const TText8* aFile,

   857                                              const char* aFunction,

   858                                              TInt aLine,

   859                                              TInt aResult,

   860                                              TInt aExpected1,

   861                                              TInt aExpected2,

   862                                              TInt aExpected3,

   863                                              TInt aExpected4,

   864                                              TInt aExpected5 )

   865     {

   866     if( !IsServerAlive() )

   867         {

   868         return KErrGeneral;

   869         }

   870 

   871     return iTestExecution->StifMacroError( aMacroType, aFile,

   872                                            aFunction, aLine,

   873                                            aResult, aExpected1,

   874                                            aExpected2, aExpected3,

   875                                            aExpected4, aExpected5 );

   876 

   877     }

   878 

   879 /*

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

   881 

   882     Class: CTestModuleIf

   883 

   884     Method: ServerAlive

   885 

   886     Description: Get saved store information after the reboot.

   887 

   888     Parameters: TInt aCode: inout: Get reboot releated integer value.

   889                 TName& aName: inout: Get reboot related string value.

   890 

   891     Return Values: TInt: Symbian OS error code.

   892 

   893     Errors/Exceptions: KErrNotReady returned if iTestExecution is NULL.

   894 

   895     Status: Proposal

   896 

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

   898 */

   899 TBool CTestModuleIf::IsServerAlive()

   900     {

   901     

   902     if( iTestExecution == NULL )

   903         {

   904         __RDEBUG( ( _L( "iTestExecution not initialised" ) ) );

   905         // Execution not initialized

   906         return EFalse;

   907         }

   908        

   909     return ETrue;

   910     

   911     }

   912 

   913 /*

   914 -------------------------------------------------------------------------------

   915 

   916     Class: CTestModuleIf

   917 

   918     Method: AddInterferenceThread

   919 

   920     Description: 

   921 

   922     Parameters: RThread aSTIFTestInterference: in: Handle to RThread

   923 

   924     Return Values: TInt: Symbian OS error code.

   925 

   926     Errors/Exceptions: 

   927 

   928     Status: Proposal

   929 

   930 -------------------------------------------------------------------------------

   931 */

   932 TInt CTestModuleIf::AddInterferenceThread( RThread aSTIFTestInterference )

   933     {

   934     // Add thread to Array. Via array can handle test interference thread's

   935     // kill in panic etc. cases

   936     return iTestExecution->AddInterferenceThread( aSTIFTestInterference );

   937 

   938     }

   939 

   940 /*

   941 -------------------------------------------------------------------------------

   942 

   943     Class: CTestModuleIf

   944 

   945     Method: RemoveInterferenceThread

   946 

   947     Description: 

   948 

   949     Parameters: RThread aSTIFTestInterference: in: Handle to RThread

   950 

   951     Return Values: TInt: Symbian OS error code.

   952 

   953     Errors/Exceptions: 

   954 

   955     Status: Proposal

   956 

   957 -------------------------------------------------------------------------------

   958 */

   959 TInt CTestModuleIf::RemoveInterferenceThread( RThread aSTIFTestInterference )

   960     {

   961     // Remove thread from Array.Test interference thread is stopped and killed

   962     // successfully

   963     return iTestExecution->RemoveInterferenceThread( aSTIFTestInterference );

   964 

   965     }

   966 

   967 /*

   968 -------------------------------------------------------------------------------

   969 

   970     Class: CTestModuleIf

   971 

   972     Method: HandleMeasurementProcess

   973 

   974     Description: With this can be stored information about test measurement

   975                  to TestServer space.

   976 

   977     Parameters: RProcess aTestMeasurement: in: Handle to RProcess

   978 

   979     Return Values: TInt: Symbian OS error code.

   980 

   981     Errors/Exceptions: 

   982 

   983     Status: Approved

   984 

   985 -------------------------------------------------------------------------------

   986 */

   987 TInt CTestModuleIf::HandleMeasurementProcess( 

   988             CSTIFTestMeasurement::TStifMeasurementStruct aSTIFMeasurementInfo )

   989     {

   990     // Add process to Array. Via array can handle test measurement process's

   991     // kill in panic etc. cases

   992     return iTestExecution->HandleMeasurementProcess( aSTIFMeasurementInfo );

   993 

   994     }

   995 

   996 /*

   997 -------------------------------------------------------------------------------

   998 

   999     Class: CTestModuleIf

  1000 

  1001     Method: GetMeasurementOptions

  1002 

  1003     Description: Get measurement option(s) given from initialization file etc.

  1004 

  1005     Parameters: TInt& aOptions: inout: Get measurement option(s)

  1006 

  1007     Return Values: TInt: Symbian OS error code.

  1008 

  1009     Errors/Exceptions: KErrNotReady returned if iTestExecution is NULL.

  1010 

  1011     Status: Approved

  1012 

  1013 -------------------------------------------------------------------------------

  1014 */

  1015 EXPORT_C TInt CTestModuleIf::GetMeasurementOptions( TInt& aOptions )

  1016     {           

  1017     if( !IsServerAlive() )

  1018         {

  1019         __RDEBUG( ( _L( "iTestExecution not initialised" ) ) );

  1020         return KErrNotReady;

  1021         }

  1022 

  1023     TParams params;

  1024     TGetMeasurementOptionsRef getMeasurementOptionsRef( aOptions );

  1025     params.aMeasurementOption = &getMeasurementOptionsRef;

  1026 

  1027     TRequestStatus status = KRequestPending; 

  1028 

  1029     // Forward

  1030     iTestExecution->DoRemoteReceive( EStifCmdMeasurement, params,

  1031                                      sizeof( TGetMeasurementOptions ), status );

  1032     

  1033     User::WaitForRequest( status );

  1034 

  1035     aOptions = getMeasurementOptionsRef.iOptions;

  1036     

  1037     return status.Int();

  1038 

  1039     }

  1040 

  1041 /*

  1042 -------------------------------------------------------------------------------

  1043 

  1044     Class: CTestModuleIf

  1045 

  1046     Method: SetAllowResult

  1047 

  1048     Description: Use with TAL, TA1L, TA2L, TA3L, TA4L and TA5L macros to allow

  1049                  results.

  1050                  Set test case allow result given by user. In TestScripter

  1051                  cases allow result can set by 'allownextresult' or

  1052                  'allowerrorcodes' keywords. In Normal and Hardcoded test

  1053                  modules allow result can be set with this method, reset should

  1054                  be done with ResetAllowResult method.

  1055 

  1056     Parameters: TInt aResult: in: Result value to be appended.

  1057 

  1058     Return Values: TInt: Symbian OS error code.

  1059 

  1060     Errors/Exceptions: None

  1061 

  1062     Status: Approved

  1063 

  1064 -------------------------------------------------------------------------------

  1065 */

  1066 EXPORT_C TInt CTestModuleIf::SetAllowResult( TInt aResult )

  1067     {

  1068     for( TInt a = 0; a < iAllowTestCaseResultsCount; a++ )

  1069         {

  1070         // Check that result is not given already

  1071         if ( iTestCaseResults[a] == aResult )

  1072             {

  1073             return KErrNone;

  1074             }

  1075         }

  1076     // If values are given more that allow(see KSTIFMacroResultArraySize).

  1077     // Array starts from 0...9 -> 10 => 10th should fail

  1078     if( iAllowTestCaseResultsCount >= KSTIFMacroResultArraySize )

  1079         {

  1080         __RDEBUG( ( 

  1081             _L( "STIF macro's SetAllowResult() allow only %d results, fails with %d" ),

  1082             KSTIFMacroResultArraySize, KErrOverflow  ) );

  1083         return KErrOverflow;

  1084         }

  1085 

  1086     // New result

  1087     iAllowTestCaseResultsCount++;

  1088     iTestCaseResults[iAllowTestCaseResultsCount-1] = aResult;

  1089 

  1090     return KErrNone;

  1091 

  1092     }

  1093 

  1094 /*

  1095 -------------------------------------------------------------------------------

  1096 

  1097     Class: CTestModuleIf

  1098 

  1099     Method: CheckAllowResult

  1100 

  1101     Description: This is mainly used by STIF's TAL-TA5L macros internally.

  1102                  Check is macros result allowed result.

  1103 

  1104     Parameters: TInt aResult: in: Result value to be checked.

  1105 

  1106     Return Values: TInt: Symbian OS error code.

  1107 

  1108     Errors/Exceptions: None

  1109 

  1110     Status: Approved

  1111 

  1112 -------------------------------------------------------------------------------

  1113 */

  1114 EXPORT_C TInt CTestModuleIf::CheckAllowResult( TInt aResult )

  1115     {

  1116     // Check is result allowed

  1117     for( TInt a = 0; a < iAllowTestCaseResultsCount; a++ )

  1118         {

  1119         if ( iTestCaseResults[a] == aResult )

  1120             {

  1121             // Result is allow

  1122             __RDEBUG( ( _L( "STIF TAL-TA5L macro's result check. Test case result[%d] allowed" ),

  1123                 aResult ) );

  1124             return KErrNone;

  1125             }

  1126         }

  1127 

  1128     __RDEBUG( ( 

  1129         _L( "STIF TAL-TA5L macro's result check. Test case result[%d] not allowed" ),

  1130         aResult ) );

  1131     // No match with allow result

  1132     return KErrGeneral;

  1133 

  1134     }