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 #include "TestScripterInternal.h"

    27 #include <e32property.h>

    28 

    29 // EXTERNAL DATA STRUCTURES

    30 // None

    31 

    32 // EXTERNAL FUNCTION PROTOTYPES  

    33 // None

    34 

    35 // CONSTANTS

    36 // None

    37 const TUid KPropertyCat =

    38     {

    39     0x101FB3DE

    40     };

    41 const TUint KPropertyKey = 0x00000001;

    42 

    43 // MACROS

    44 // Debugging is enabled with next define

    45 #define __TRACING_ENABLED

    46 #ifdef __TRACING_ENABLED

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

    48 #else

    49 #define __RDEBUG(p)

    50 #endif

    51 

    52 // LOCAL CONSTANTS AND MACROS

    53 // None

    54 

    55 // MODULE DATA STRUCTURES

    56 // None

    57 

    58 // LOCAL FUNCTION PROTOTYPES

    59 // None

    60 

    61 static RPointerArray<TScriptObject> *getDict()

    62     {

    63     TInt script = 0;

    64     TInt err = RProperty::Get(KPropertyCat, RProcess().Id().Id(), script);

    65     if (err != KErrNone)

    66         {

    67         return NULL;

    68         }

    69     return (RPointerArray<TScriptObject> *) script;

    70     }

    71 

    72 // FORWARD DECLARATIONS

    73 // None

    74 

    75 // ==================== LOCAL FUNCTIONS =======================================

    76 

    77 /*

    78 -------------------------------------------------------------------------------

    79 

    80     DESCRIPTION

    81 

    82     TDesOverflowHandler class contains a simple overflow handler implementation.

    83 

    84 -------------------------------------------------------------------------------

    85 */

    86 class TDesOverflowHandler : public TDes16Overflow

    87     {

    88     public:

    89         TDesOverflowHandler( CTestModuleIf* aModuleIf, 

    90                              const TInt aPriority, 

    91                              const TDesC& aDefinition)

    92             {

    93             iModuleIf = aModuleIf;

    94             iPriority = aPriority;

    95             iDefinition = aDefinition;

    96             }

    97 

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

    99             { 

   100             }

   101     

   102         CTestModuleIf* iModuleIf;

   103         TInt iPriority;

   104         TStifInfoName iDefinition;

   105     };

   106 

   107 /*

   108 -------------------------------------------------------------------------------

   109 

   110     DESCRIPTION

   111 

   112     This module contains the implementation of CTestModuleIf class 

   113     member functions.

   114 

   115 -------------------------------------------------------------------------------

   116 */

   117 

   118 // ================= MEMBER FUNCTIONS =========================================

   119 

   120 /*

   121 -------------------------------------------------------------------------------

   122 

   123     Class: CTestModuleIf

   124 

   125     Method: CTestModuleIf

   126 

   127     Description: Default constructor

   128 

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

   130     might leave.

   131     

   132     Parameters: None

   133     

   134     Return Values: None

   135     

   136     Errors/Exceptions: None

   137     

   138     Status: Approved

   139     

   140 -------------------------------------------------------------------------------

   141 */

   142 CTestModuleIf::CTestModuleIf( CTestThreadContainer* aTestExecution ) :

   143     iTestExecution( aTestExecution )

   144     {

   145     iNumberInGlbDict = 0;

   146     }

   147 

   148 /*

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

   150 

   151     Class: CTestModuleIf

   152 

   153     Method: ConstructL

   154 

   155     Description: Symbian OS second phase constructor

   156 

   157     Symbian OS default constructor can leave.

   158 

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

   160                 CTestModuleBase* aTestModule: in: Pointer to TestModule

   161     

   162     Return Values: None

   163     

   164     Errors/Exceptions: None

   165     

   166     Status: Approved

   167     

   168 -------------------------------------------------------------------------------

   169 */

   170 void CTestModuleIf::ConstructL( CTestModuleBase* aTestModule )

   171     {

   172 

   173     if ( aTestModule->iTestModuleIf != NULL)

   174         {

   175         delete aTestModule->iTestModuleIf;

   176         aTestModule->iTestModuleIf = NULL;

   177         }

   178     aTestModule->iTestModuleIf = this; 

   179 

   180     iIsRebootReady = EFalse;

   181     iStoreStateCounter = 0;

   182 

   183     // Used to "resets" iTestCaseResults array

   184     iAllowTestCaseResultsCount = 0;

   185 

   186     }

   187 

   188 /*

   189 -------------------------------------------------------------------------------

   190 

   191     Class: CTestModuleIf

   192 

   193     Method: NewL

   194 

   195     Description: Two-phased constructor.

   196 

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

   198                 CTestModuleBase* aTestModule: in: Pointer to TestModule

   199     

   200     Return Values: CTestModuleIf object.

   201 

   202     Errors/Exceptions: Leaves if memory allocation fails

   203                        Leaves if ConstructL leaves

   204 

   205     Status: Approved

   206     

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

   208 */

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

   210                                              CTestModuleBase* aTestModule )

   211     {

   212 

   213     CTestModuleIf* self = 

   214         new (ELeave) CTestModuleIf( aExecutionSession );

   215     

   216     CleanupStack::PushL( self );

   217     self->ConstructL( aTestModule );

   218 

   219     CleanupStack::Pop();

   220 

   221     return self;

   222 

   223     }

   224 

   225 /*

   226 -------------------------------------------------------------------------------

   227 

   228     Class: CTestModuleIf

   229 

   230     Method: ~CTestModuleIf

   231 

   232     Description: Destructor

   233     

   234     Parameters: None

   235     

   236     Return Values: None

   237 

   238     Errors/Exceptions: None

   239     

   240     Status: Approved

   241     

   242 -------------------------------------------------------------------------------

   243 */    

   244 CTestModuleIf::~CTestModuleIf()

   245     {

   246     iTestExecution = NULL;

   247 

   248     // Used to "resets" iTestCaseResults array

   249     iAllowTestCaseResultsCount = 0;

   250     }

   251 

   252 /*

   253 -------------------------------------------------------------------------------

   254 

   255     Class: CTestModuleIf

   256 

   257     Method: Printf

   258 

   259     Description: Printing

   260 

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

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

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

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

   265     the different performance situations. The priority is also 

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

   267     the Printf responses.

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

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

   270 

   271     Parameters:  const TInt aPriority: in: 

   272                     Importance of the returned information

   273                  const TDesC& aDefinition: in: 

   274                     Definition of data to be printed 

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

   276     

   277     Return Values: None

   278     

   279     Errors/Exceptions: None

   280     

   281     Status: Approved

   282     

   283 -------------------------------------------------------------------------------

   284 */

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

   286                                      const TDesC& aDefinition, 

   287                                      TRefByValue<const TDesC> aFmt,

   288                                      ... 

   289                                    )

   290     {           

   291 

   292     if( !IsServerAlive() )

   293         {

   294         return;

   295         }

   296 

   297     VA_LIST list;

   298     VA_START(list,aFmt);

   299     TName aBuf;

   300     RBuf buf;

   301     TInt ret = buf.Create(1024);

   302     if(ret != KErrNone)

   303         {

   304         __RDEBUG((_L("STF: Printf: Buffer creation failed [%d]"), ret));

   305         return;

   306         }

   307 

   308     // Cut the description length

   309     TInt len = aDefinition.Length();

   310     if ( len > KMaxInfoName )

   311         {

   312         len = KMaxInfoName;

   313         }

   314 

   315     TStifInfoName shortDescription = aDefinition.Left(len);

   316 

   317     // Create overflow handler

   318     TDesOverflowHandler overFlowHandler (this, aPriority, shortDescription);

   319 

   320     // Parse parameters

   321     buf.AppendFormatList(aFmt, list, &overFlowHandler);

   322     

   323     if(buf.Length() == 0)

   324         {

   325         __RDEBUG((_L("STF: Printf: Unable to prepare print buffer (probably printed string is too long)")));

   326         }

   327 

   328     // Print

   329     aBuf.Copy(buf.Left(aBuf.MaxLength()));

   330     buf.Close();

   331 

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

   333 

   334     }

   335 

   336 /*

   337 -------------------------------------------------------------------------------

   338 

   339     Class: CTestModuleIf

   340 

   341     Method: Event

   342 

   343     Description: Event control.

   344 

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

   346     TEventIf &aEvent encapsulates the request type and 

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

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

   349     can call it to control the event system.

   350   

   351     Parameters: TEventIf& aEvent: in: Event command

   352     

   353     Return Values: Symbian OS error code.

   354 

   355     Errors/Exceptions: None

   356 

   357     Status: Approved

   358     

   359 -------------------------------------------------------------------------------

   360 */      

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

   362     {

   363 

   364     if( !IsServerAlive() )

   365         {

   366         return KErrGeneral;

   367         }

   368 

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

   370     return iTestExecution->DoNotifyEvent( aEvent );

   371     

   372     }

   373 

   374 /*

   375 -------------------------------------------------------------------------------

   376 

   377     Class: CTestModuleIf

   378 

   379     Method: Event

   380 

   381     Description: Event control.

   382 

   383     Asynchronous version of event control function.

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

   385     TEventIf &aEvent encapsulates the request type and 

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

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

   388     can call it to control the event system.

   389   

   390     Parameters: TEventIf& aEvent: in: Event command

   391                 TRequestStatus& aStatus: in: Request status parameter

   392 

   393     Return Values: None. 

   394     

   395     Errors/Exceptions: None

   396 

   397     Status: Approved

   398     

   399 -------------------------------------------------------------------------------

   400 */      

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

   402     {

   403     TInt ret = KErrNone;

   404 

   405     if( !IsServerAlive() )

   406         {

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

   408         ret = KErrGeneral;

   409         }

   410     else

   411         {        

   412         aStatus = KRequestPending;

   413 

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

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

   416         }

   417     if( ret != KErrNone )

   418         {

   419         TRequestStatus* rs = &aStatus;

   420         User::RequestComplete( rs, ret );

   421         }

   422     

   423     }

   424     

   425 /*

   426 -------------------------------------------------------------------------------

   427 

   428     Class: CTestModuleIf

   429 

   430     Method: CancelEvent

   431 

   432     Description: Cancel asynchronous event control call.

   433   

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

   435                 const TRequestStatus* aStatus: in: 

   436                     Pointer to TRequestStatus parameter that is cancelled

   437 

   438     Return Values: Symbian OS error code.

   439     

   440     Errors/Exceptions: None

   441     

   442     Status: Approved

   443     

   444 -------------------------------------------------------------------------------

   445 */      

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

   447                                           TRequestStatus* aStatus )

   448     {

   449      if( !IsServerAlive() )

   450         {

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

   452         return KErrGeneral;

   453         }

   454 

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

   456     iTestExecution->CancelEvent( aEvent, aStatus );

   457     

   458     return KErrNone;

   459     

   460     }

   461 

   462 

   463 /*

   464 -------------------------------------------------------------------------------

   465 

   466     Class: CTestModuleIf

   467 

   468     Method: SetExitReason

   469 

   470     Description: Set exit reason

   471   

   472     Parameters: const TExitReason aExitReason in: Exit reason

   473                 const TInt aExitCode in: Exit code

   474 

   475     Return Values: None

   476     

   477     Errors/Exceptions: None

   478     

   479     Status: Proposal

   480     

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

   482 */      

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

   484                                             const TInt aExitCode )

   485         

   486     {

   487 

   488      if( !IsServerAlive() )

   489         {

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

   491         return;

   492         }

   493     

   494     iTestExecution->SetExitReason( aExitReason, aExitCode );

   495     

   496     }

   497 

   498 /*

   499 -------------------------------------------------------------------------------

   500 

   501     Class: CTestModuleIf

   502 

   503     Method: RemoteSend

   504 

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

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

   507     

   508     Parameters:  const TDesC& aRemoteMsg: in: 

   509                     Remote command protocol message 

   510                  

   511     Return Values: None

   512     

   513     Errors/Exceptions: None

   514     

   515     Status: Proposal

   516     

   517 -------------------------------------------------------------------------------

   518 */

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

   520     {           

   521 

   522     if( !IsServerAlive() )

   523         {

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

   525         return KErrNotReady;

   526         }

   527 

   528     TParams params;

   529     params.aRemoteMsgConstRef = &aRemoteMsg;

   530 

   531     TRequestStatus status = KRequestPending; 

   532 

   533     // Forward

   534     iTestExecution->DoRemoteReceive( EStifCmdSend, params, 

   535                                      aRemoteMsg.Length(), status );

   536     

   537     User::WaitForRequest( status );

   538 

   539     return status.Int();

   540 

   541     }

   542     

   543 /*

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

   545 

   546     Class: CTestModuleIf

   547 

   548     Method: RemoteReceive

   549 

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

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

   552     

   553     Parameters:  const TDesC& aRemoteMsg: in: 

   554                     Remote command protocol message 

   555                  TRequestStatus& aStatus: in: Request status parameter

   556 

   557     Return Values: None

   558     

   559     Errors/Exceptions: None

   560     

   561     Status: Proposal

   562     

   563 -------------------------------------------------------------------------------

   564 */

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

   566                                             TRequestStatus& aStatus )

   567     {           

   568     aStatus = KRequestPending;

   569     if( !IsServerAlive() )

   570         {

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

   572         TRequestStatus* rs = &aStatus;

   573         User::RequestComplete( rs, KErrNotReady );

   574         }

   575 

   576     TParams params;

   577     params.aRemoteMsgRef = &aRemoteMsg;

   578 

   579     iTestExecution->DoRemoteReceive( EStifCmdReceive, params, 

   580                                      aRemoteMsg.Length(), aStatus );

   581 

   582     }

   583     

   584 /*

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

   586 

   587     Class: CTestModuleIf

   588 

   589     Method: RemoteReceiveCancel

   590 

   591     Description: RemoteReceiveCancel is used to cancel RemoteReceive.

   592      

   593     Parameters:  None

   594     

   595     Return Values: None

   596     

   597     Errors/Exceptions: None

   598     

   599     Status: Proposal

   600     

   601 -------------------------------------------------------------------------------

   602 */

   603 EXPORT_C void CTestModuleIf::RemoteReceiveCancel()

   604     {           

   605     if( !IsServerAlive() )

   606         {

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

   608         return;

   609         }

   610 

   611     // Forward

   612     iTestExecution->DoRemoteReceiveCancel();

   613 

   614     }

   615 

   616 /*

   617 -------------------------------------------------------------------------------

   618 

   619     Class: CTestModuleIf

   620 

   621     Method: Reboot

   622 

   623     Description: Start a reboot operation.

   624 

   625     Parameters: TInt aType: in: Reboot type

   626 

   627     Return Values: TInt: Symbian OS error code.

   628 

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

   630                        KErrNotReady returned if reboot not allowed(Store state

   631                        not called).

   632 

   633     Status: Proposal

   634 

   635 -------------------------------------------------------------------------------

   636 */

   637 EXPORT_C TInt CTestModuleIf::Reboot( TInt aType )

   638     {           

   639     if ( !IsServerAlive() )

   640         {

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

   642         return KErrNotReady;

   643         }

   644     if( !iIsRebootReady )

   645         {

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

   647         return KErrNotReady;

   648         }

   649      

   650 /*    switch( aType )

   651         {

   652         case EDefaultReset:

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

   654             break;

   655         case EKernelReset:

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

   657             break;

   658         case EDeviceReset0:

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

   660             break;

   661         case EDeviceReset1:

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

   663             break;

   664         case EDeviceReset2:

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

   666             break;

   667         case EDeviceReset3:

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

   669             break;

   670         case EDeviceReset4:

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

   672             break;

   673         case EDeviceReset5:

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

   675             break;

   676         default:

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

   678             return KErrNotSupported;    

   679         }

   680 */

   681 

   682     TParams params;

   683     TRebootParams rebootParams;

   684     

   685     params.aRebootType = &rebootParams;

   686     rebootParams.aType = ( TRebootType )aType;

   687     

   688     TRequestStatus status = KRequestPending; 

   689 

   690     // Forward

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

   692     

   693     User::WaitForRequest( status );

   694 

   695     return status.Int();

   696     

   697     }

   698 

   699 /*

   700 -------------------------------------------------------------------------------

   701 

   702     Class: CTestModuleIf

   703 

   704     Method: StoreState

   705 

   706     Description: Stores the current state before reboot.

   707 

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

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

   710 

   711     Return Values: TInt: Symbian OS error code.

   712 

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

   714                        KErrOverflow returned if aName length is over TName.

   715                        KErrInUse returned if method is called more than once.

   716 

   717     Status: Proposal

   718 

   719 -------------------------------------------------------------------------------

   720 */

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

   722     {

   723     iStoreStateCounter++;   // Store state counter

   724 

   725     if ( !IsServerAlive() )

   726         {

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

   728         return KErrNotReady;

   729         }

   730     // Check aName length

   731     if ( aName.Length() > KMaxName )

   732         {

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

   734         return KErrOverflow;

   735         }

   736     // Only one store state call may be done

   737     if( iStoreStateCounter > 1 )

   738         {

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

   740         return KErrInUse;

   741         }

   742 

   743     TParams params;

   744     TRebootStateParams rebootStateParams;

   745     params.aRebootState = &rebootStateParams;

   746     rebootStateParams.aCode = aCode;

   747     rebootStateParams.aName = aName;

   748 

   749     TRequestStatus status = KRequestPending; 

   750 

   751     // Forward

   752     iTestExecution->DoRemoteReceive( EStifCmdStoreState, params,

   753                                      sizeof( TRebootStateParams), status );

   754     

   755     User::WaitForRequest( status );

   756 

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

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

   759         {

   760         iIsRebootReady = ETrue;

   761         }

   762 

   763     return status.Int();

   764 

   765     }

   766 

   767 /*

   768 -------------------------------------------------------------------------------

   769 

   770     Class: CTestModuleIf

   771 

   772     Method: GetStoredState

   773 

   774     Description: Get saved store information after the reboot.

   775 

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

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

   778 

   779     Return Values: TInt: Symbian OS error code.

   780 

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

   782 

   783     Status: Proposal

   784 

   785 -------------------------------------------------------------------------------

   786 */

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

   788     {           

   789     if( !IsServerAlive() )

   790         {

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

   792         return KErrNotReady;

   793         }

   794 

   795     TInt code;

   796     TName name;

   797     

   798     TParams params;

   799     TGetRebootStoredParamsRef getRebootStoredParamsRef( code, name );

   800     

   801     params.aRebootStoredRef = &getRebootStoredParamsRef;

   802 

   803     TRequestStatus status = KRequestPending; 

   804 

   805     // Forward

   806     iTestExecution->DoRemoteReceive( EStifCmdGetStoredState, params,

   807                                      sizeof( TRebootStateParams), status );

   808     

   809     User::WaitForRequest( status );

   810 

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

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

   813         {

   814         aCode = code;

   815         aName = name;

   816         }

   817 

   818     return status.Int();

   819 

   820     }

   821 

   822 /*

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

   824 

   825     Class: CTestModuleIf

   826 

   827     Method: SetBehavior

   828 

   829     Description: Set test case behavior.

   830 

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

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

   833 

   834     Return Values: TInt: Symbian OS error code.

   835 

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

   837 

   838     Status: Proposal

   839 

   840 -------------------------------------------------------------------------------

   841 */

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

   843     {         

   844     

   845     if( !IsServerAlive() )

   846         {

   847         return KErrGeneral;

   848         }

   849 

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

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

   852     

   853     }

   854 

   855 /*

   856 -------------------------------------------------------------------------------

   857 

   858     Class: CTestModuleIf

   859 

   860     Method: StifMacroError

   861 

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

   863 

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

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

   866                 path and file name. Maximun length for this is

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

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

   869                 function name. Maximun length for this is

   870                 KStifMacroMaxFunction. If length is more then cutted from

   871                 rigth.

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

   873                 TInt aResult: in: Result from called operations.

   874                 TInt aExpected1: in: Users expected result.

   875                 TInt aExpected2: in: Users expected result.

   876                 TInt aExpected3: in: Users expected result.

   877                 TInt aExpected4: in: Users expected result.

   878                 TInt aExpected5: in: Users expected result.

   879 

   880     Return Values: Symbian OS error code.

   881 

   882     Errors/Exceptions: None

   883 

   884     Status: Proposal

   885 

   886 -------------------------------------------------------------------------------

   887 */

   888 EXPORT_C TInt CTestModuleIf::StifMacroError( TInt aMacroType, 

   889                                              const TText8* aFile,

   890                                              const char* aFunction,

   891                                              TInt aLine,

   892                                              TInt aResult,

   893                                              TInt aExpected1,

   894                                              TInt aExpected2,

   895                                              TInt aExpected3,

   896                                              TInt aExpected4,

   897                                              TInt aExpected5 )

   898     {

   899     if( !IsServerAlive() )

   900         {

   901         return KErrGeneral;

   902         }

   903 

   904     return iTestExecution->StifMacroError( aMacroType, aFile,

   905                                            aFunction, aLine,

   906                                            aResult, aExpected1,

   907                                            aExpected2, aExpected3,

   908                                            aExpected4, aExpected5 );

   909 

   910     }

   911 

   912 /*

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

   914 

   915     Class: CTestModuleIf

   916 

   917     Method: ServerAlive

   918 

   919     Description: Get saved store information after the reboot.

   920 

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

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

   923 

   924     Return Values: TInt: Symbian OS error code.

   925 

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

   927 

   928     Status: Proposal

   929 

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

   931 */

   932 TBool CTestModuleIf::IsServerAlive()

   933     {

   934     

   935     if( iTestExecution == NULL )

   936         {

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

   938         // Execution not initialized

   939         return EFalse;

   940         }

   941        

   942     return ETrue;

   943     

   944     }

   945 

   946 /*

   947 -------------------------------------------------------------------------------

   948 

   949     Class: CTestModuleIf

   950 

   951     Method: AddInterferenceThread

   952 

   953     Description: 

   954 

   955     Parameters: RThread aSTIFTestInterference: in: Handle to RThread

   956 

   957     Return Values: TInt: Symbian OS error code.

   958 

   959     Errors/Exceptions: 

   960 

   961     Status: Proposal

   962 

   963 -------------------------------------------------------------------------------

   964 */

   965 TInt CTestModuleIf::AddInterferenceThread( RThread aSTIFTestInterference )

   966     {

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

   968     // kill in panic etc. cases

   969     return iTestExecution->AddInterferenceThread( aSTIFTestInterference );

   970 

   971     }

   972 

   973 /*

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

   975 

   976     Class: CTestModuleIf

   977 

   978     Method: RemoveInterferenceThread

   979 

   980     Description: 

   981 

   982     Parameters: RThread aSTIFTestInterference: in: Handle to RThread

   983 

   984     Return Values: TInt: Symbian OS error code.

   985 

   986     Errors/Exceptions: 

   987 

   988     Status: Proposal

   989 

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

   991 */

   992 TInt CTestModuleIf::RemoveInterferenceThread( RThread aSTIFTestInterference )

   993     {

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

   995     // successfully

   996     return iTestExecution->RemoveInterferenceThread( aSTIFTestInterference );

   997 

   998     }

   999 

  1000 /*

  1001 -------------------------------------------------------------------------------

  1002 

  1003     Class: CTestModuleIf

  1004 

  1005     Method: HandleMeasurementProcess

  1006 

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

  1008                  to TestServer space.

  1009 

  1010     Parameters: RProcess aTestMeasurement: in: Handle to RProcess

  1011 

  1012     Return Values: TInt: Symbian OS error code.

  1013 

  1014     Errors/Exceptions: 

  1015 

  1016     Status: Approved

  1017 

  1018 -------------------------------------------------------------------------------

  1019 */

  1020 TInt CTestModuleIf::HandleMeasurementProcess( 

  1021             CSTIFTestMeasurement::TStifMeasurementStruct aSTIFMeasurementInfo )

  1022     {

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

  1024     // kill in panic etc. cases

  1025     return iTestExecution->HandleMeasurementProcess( aSTIFMeasurementInfo );

  1026 

  1027     }

  1028 

  1029 /*

  1030 -------------------------------------------------------------------------------

  1031 

  1032     Class: CTestModuleIf

  1033 

  1034     Method: GetMeasurementOptions

  1035 

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

  1037 

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

  1039 

  1040     Return Values: TInt: Symbian OS error code.

  1041 

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

  1043 

  1044     Status: Approved

  1045 

  1046 -------------------------------------------------------------------------------

  1047 */

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

  1049     {           

  1050     if( !IsServerAlive() )

  1051         {

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

  1053         return KErrNotReady;

  1054         }

  1055 

  1056     TParams params;

  1057     TGetMeasurementOptionsRef getMeasurementOptionsRef( aOptions );

  1058     params.aMeasurementOption = &getMeasurementOptionsRef;

  1059 

  1060     TRequestStatus status = KRequestPending; 

  1061 

  1062     // Forward

  1063     iTestExecution->DoRemoteReceive( EStifCmdMeasurement, params,

  1064                                      sizeof( TGetMeasurementOptions ), status );

  1065     

  1066     User::WaitForRequest( status );

  1067 

  1068     aOptions = getMeasurementOptionsRef.iOptions;

  1069     

  1070     return status.Int();

  1071 

  1072     }

  1073 

  1074 /*

  1075 -------------------------------------------------------------------------------

  1076 

  1077     Class: CTestModuleIf

  1078 

  1079     Method: SetAllowResult

  1080 

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

  1082                  results.

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

  1084                  cases allow result can set by 'allownextresult' or

  1085                  'allowerrorcodes' keywords. In Normal and Hardcoded test

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

  1087                  be done with ResetAllowResult method.

  1088 

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

  1090 

  1091     Return Values: TInt: Symbian OS error code.

  1092 

  1093     Errors/Exceptions: None

  1094 

  1095     Status: Approved

  1096 

  1097 -------------------------------------------------------------------------------

  1098 */

  1099 EXPORT_C TInt CTestModuleIf::SetAllowResult( TInt aResult )

  1100     {

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

  1102         {

  1103         // Check that result is not given already

  1104         if ( iTestCaseResults[a] == aResult )

  1105             {

  1106             return KErrNone;

  1107             }

  1108         }

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

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

  1111     if( iAllowTestCaseResultsCount >= KSTIFMacroResultArraySize )

  1112         {

  1113         __RDEBUG( ( 

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

  1115             KSTIFMacroResultArraySize, KErrOverflow  ) );

  1116         return KErrOverflow;

  1117         }

  1118 

  1119     // New result

  1120     iAllowTestCaseResultsCount++;

  1121     iTestCaseResults[iAllowTestCaseResultsCount-1] = aResult;

  1122 

  1123     return KErrNone;

  1124 

  1125     }

  1126 

  1127 /*

  1128 -------------------------------------------------------------------------------

  1129 

  1130     Class: CTestModuleIf

  1131 

  1132     Method: CheckAllowResult

  1133 

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

  1135                  Check is macros result allowed result.