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 the header file of the 

    15 * CTestModuleBase and CTestModuleIf classes. Test Module inherits 

    16 * the CTestModuleBase and uses the CTestModuleIf for printing 

    17 * to user interface and event system control.

    18 *

    19 * The initialization of this interface must be done from the Test Module Server with:

    20 * 	CTestModuleXXX *mod = new CTestModuleXXX;

    21 * 	RThread thread;

    22 * 	CTestModuleIf::NewL( this, (CTestModuleBase*) mod, thread.Id() );

    23 * 

    24 * CTestModuleIf is deleted by destructor of the CTestModuleBase. 

    25 *

    26 */

    27 

    28 #ifndef TESTMODULE_H

    29 #define TESTMODULE_H

    30 

    31 // INCLUDES

    32 #include <e32std.h>

    33 #include <e32base.h>

    34 #include "StifCommand.h"

    35 

    36 // CONSTANTS

    37 

    38 // Define Old Test Module API version - API that doesn't support version of test module

    39 const TInt KOldTestModuleAPIMajor = 1;

    40 const TInt KOldTestModuleAPIMinor = 1;

    41 const TInt KOldTestModuleAPIBuild = 0;

    42 

    43 // Define Test Module API version

    44 const TInt KTestModuleAPIMajor = 1;

    45 const TInt KTestModuleAPIMinor = 2;

    46 const TInt KTestModuleAPIBuild = 0;

    47 const TInt KStifMaxResultDes = 128; // Maximum test result description length

    48 

    49 // Max array value for STIF macros allow result.

    50 const TInt KSTIFMacroResultArraySize = 10;

    51 

    52 // Test module def-file check when setting parameters.

    53 const TUint32 KStifTestModuleParameterChanged = 0xdeadbeef;

    54 

    55 // MACROS

    56 // Test result description. Maximum length is 128 characters.

    57 typedef TBuf<KStifMaxResultDes> TResultDes;

    58 

    59 // Macro for boolean.

    60 #ifdef TL

    61     #pragma message( "============================================================" )

    62     #pragma message( " TL macro is already defined, now using STIF TF's TL macro" )

    63     #pragma message( "============================================================" )

    64 #undef TL

    65 #endif

    66 // Macro for integer and one expected result.

    67 #ifdef T1L

    68     #pragma message( "==============================================================" )

    69     #pragma message( " T1L macro is already defined, now using STIF TF's T1L macro" )

    70     #pragma message( "==============================================================" )

    71 #undef T1L

    72 #endif

    73 // Macro for integer and two expected result.

    74 #ifdef T2L

    75     #pragma message( "==============================================================" )

    76     #pragma message( " T2L macro is already defined, now using STIF TF's T2L macro" )

    77     #pragma message( "==============================================================" )

    78 #undef T2L

    79 #endif

    80 // Macro for integer and three expected result.

    81 #ifdef T3L

    82     #pragma message( "==============================================================" )

    83     #pragma message( " T3L macro is already defined, now using STIF TF's T3L macro" )

    84     #pragma message( "==============================================================" )

    85 #undef T3L

    86 #endif

    87 // Macro for integer and four expected result.

    88 #ifdef T4L

    89     #pragma message( "==============================================================" )

    90     #pragma message( " T4L macro is already defined, now using STIF TF's T4L macro" )

    91     #pragma message( "==============================================================" )

    92 #undef T4L

    93 #endif

    94 // Macro for integer and five expected result.

    95 #ifdef T5L

    96     #pragma message( "==============================================================" )

    97     #pragma message( " T5L macro is already defined, now using STIF TF's T5L macro" )

    98     #pragma message( "==============================================================" )

    99 #undef T5L

   100 #endif

   101 

   102 // Macro for boolean. Recommended use with TestScripter's test class.

   103 #ifdef TAL

   104     #pragma message( "==============================================================" )

   105     #pragma message( " TAL macro is already defined, now using STIF TF's TAL macro" )

   106     #pragma message( "==============================================================" )

   107 #undef TAL

   108 #endif

   109 // Macro for integer and one expected result. Recommended use with TestScripter's test

   110 // class.

   111 #ifdef TA1L

   112     #pragma message( "================================================================" )

   113     #pragma message( " TA1L macro is already defined, now using STIF TF's TA1L macro" )

   114     #pragma message( "================================================================" )

   115 #undef TA1L

   116 #endif

   117 // Macro for integer and two expected result. Recommended use with TestScripter's test

   118 // class.

   119 #ifdef TA2L

   120     #pragma message( "================================================================" )

   121     #pragma message( " TA2L macro is already defined, now using STIF TF's TA2L macro" )

   122     #pragma message( "================================================================" )

   123 #undef TA2L

   124 #endif

   125 // Macro for integer and three expected result. Recommended use with TestScripter's test

   126 // class.

   127 #ifdef TA3L

   128     #pragma message( "================================================================" )

   129     #pragma message( " TA3L macro is already defined, now using STIF TF's TA3L macro" )

   130     #pragma message( "================================================================" )

   131 #undef TA3L

   132 #endif

   133 // Macro for integer and four expected result. Recommended use with TestScripter's test

   134 // class.

   135 #ifdef TA4L

   136     #pragma message( "================================================================" )

   137     #pragma message( " TA4L macro is already defined, now using STIF TF's TA4L macro" )

   138     #pragma message( "================================================================" )

   139 #undef TA4L

   140 #endif

   141 // Macro for integer and five expected result. Recommended use with TestScripter's test

   142 // class.

   143 #ifdef TA5L

   144     #pragma message( "================================================================" )

   145     #pragma message( " TA5L macro is already defined, now using STIF TF's TA5L macro" )

   146     #pragma message( "================================================================" )

   147 #undef TA5L

   148 #endif

   149 

   150 

   151 //  TL ========================================================================

   152 //  Macro for verify boolean value.

   153 //  Example for use, 1: TL( Open() == KErrNone );

   154 //                   1: TL( VerifyString1() == VerifyString2() );

   155 //                   2: TL( 6 <= 8 );

   156 //  ===========================================================================

   157     #define TL( aIsTrue )\

   158         if( (!(aIsTrue)) )\

   159         { TestModuleIf().StifMacroError( (0), (TText8*)__FILE__, __FUNCTION__, __LINE__ );\

   160         User::Leave( KErrArgument ); };

   161 

   162 //  T1L =======================================================================

   163 //  Macro for verify integer value from the expected 1 value.

   164 //  Example: T1L( Open(), KErrNone );

   165 //  ===========================================================================

   166     #define T1L( aResult, aExpected1 )\

   167         {\

   168         TInt result = aResult;\

   169         if( ( (result) != (aExpected1) ) )\

   170             { TestModuleIf().StifMacroError(\

   171                 (1), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), (aExpected1) );\

   172             User::Leave( KErrArgument ); };\

   173         };

   174 

   175 //  T2L =======================================================================

   176 //  Macro for verify integer value from the expected 1 and 2 values.

   177 //  Example for use: T1L( Open(), KErrNone, KErrAlreadyExists );

   178 //  ===========================================================================

   179     #define T2L( aResult, aExpected1, aExpected2 )\

   180         {\

   181         TInt result = aResult;\

   182         if( ( (result) != (aExpected1) && (result) != (aExpected2) ) )\

   183             { TestModuleIf().StifMacroError(\

   184                 (2), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), (aExpected1), (aExpected2) );\

   185             User::Leave( KErrArgument ); };\

   186         };

   187 

   188 //  T3L =======================================================================

   189 //  Macro for verify integer value from the expected 1, 2 and 3 values.

   190 //  Example for use: T1L( Open(), KErrNone, KErrAlreadyExists, KErrDiskFull );

   191 //  ===========================================================================

   192     #define T3L( aResult, aExpected1, aExpected2, aExpected3 )\

   193         {\

   194         TInt result = aResult;\

   195         if( ( (result) != (aExpected1) && (result) != (aExpected2) && (result) != (aExpected3) ) )\

   196             { TestModuleIf().StifMacroError(\

   197                 (3), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), (aExpected1), (aExpected2), (aExpected3) );\

   198             User::Leave( KErrArgument ); };\

   199         };

   200 

   201 //  T4L =======================================================================

   202 //  Macro for verify integer value from the expected 1, 2, 3 and 4 values.

   203 //  Example for use:

   204 //  T1L( Open(), KErrNone, KErrAlreadyExists, KErrDiskFull, KErrDisconnected );

   205 //  ===========================================================================

   206     #define T4L( aResult, aExpected1, aExpected2, aExpected3, aExpected4 )\

   207         {\

   208         TInt result = aResult;\

   209         if( ( (result) != (aExpected1) && \

   210               (result) != (aExpected2) && \

   211               (result) != (aExpected3) && \

   212               (result) != (aExpected4) ) )\

   213             { TestModuleIf().StifMacroError(\

   214                 (4), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), \

   215                 (aExpected1), (aExpected2), (aExpected3), (aExpected4) );\

   216             User::Leave( KErrArgument ); };\

   217         };

   218 

   219 //  T5L =======================================================================

   220 //  Macro for verify integer value from the expected 1, 2, 3, 4 and 5 values.

   221 //  Example for use:

   222 //  T1L( Open(), KErrNone, KErrDied, KErrInUse, KErrDisconnected, KErrAbort );

   223 //  ===========================================================================

   224     #define T5L( aResult, aExpected1, aExpected2, aExpected3, aExpected4, aExpected5 )\

   225         {\

   226         TInt result = aResult;\

   227         if( ( (result) != (aExpected1) && \

   228               (result) != (aExpected2) && \

   229               (result) != (aExpected3) && \

   230               (result) != (aExpected4) && \

   231               (result) != (aExpected5) ) )\

   232             { TestModuleIf().StifMacroError(\

   233                 (5), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), \

   234                 (aExpected1), (aExpected2), (aExpected3), (aExpected4), (aExpected5) );\

   235             User::Leave( KErrArgument ); };\

   236         };

   237 

   238 

   239 //  TAL ========================================================================

   240 //  Macro for verify boolean value. 

   241 //  Recommended use with TestScripter's test class. Allowed result can be defined

   242 //  with 'allownextresult' and 'allowerrorcodes' keywords.

   243 //  Example for use, 1: TL( Open() == KErrNone );

   244 //                   1: TL( VerifyString1() == VerifyString2() );

   245 //                   2: TL( 6 <= 8 );

   246 //  =============================================================================

   247     #define TAL( aIsTrue )\

   248         if( ( !(aIsTrue) ) && TestModuleIf().CheckAllowResult( 0 /* = EFalse*/ ) )\

   249             { TestModuleIf().StifMacroError( (0), (TText8*)__FILE__, __FUNCTION__, __LINE__ );\

   250             User::Leave( KErrArgument ); };

   251 

   252 //  TA1L =======================================================================

   253 //  Macro for verify integer value from the expected 1 value. 

   254 //  Recommended use with TestScripter's test class. Allowed result can be defined

   255 //  with 'allownextresult' and 'allowerrorcodes' keywords.

   256 //  Example: T1L( Open(), KErrNone );

   257 //  =============================================================================

   258     #define TA1L( aResult, aExpected1 )\

   259         {\

   260         TInt result = aResult;\

   261         if( ( (result) != (aExpected1) ) && \

   262                TestModuleIf().CheckAllowResult( result ) ) \

   263             { TestModuleIf().StifMacroError(\

   264                 (1), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), (aExpected1) );\

   265             User::Leave( KErrArgument ); };\

   266         };

   267 

   268 //  TA2L =======================================================================

   269 //  Macro for verify integer value from the expected 1 and 2 values.

   270 //  Recommended use with TestScripter's test class. Allowed result can be defined

   271 //  with 'allownextresult' and 'allowerrorcodes' keywords.

   272 //  Example for use: T1L( Open(), KErrNone, KErrAlreadyExists );

   273 //  =============================================================================

   274     #define TA2L( aResult, aExpected1, aExpected2 )\

   275         {\

   276         TInt result = aResult;\

   277         if( ( (result) != (aExpected1) && (result) != (aExpected2) ) && \

   278                TestModuleIf().CheckAllowResult( result ) ) \

   279             { TestModuleIf().StifMacroError(\

   280                 (2), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), (aExpected1), (aExpected2) );\

   281             User::Leave( KErrArgument ); };\

   282         };

   283 

   284 //  TA3L =======================================================================

   285 //  Macro for verify integer value from the expected 1, 2 and 3 values. 

   286 //  Recommended use with TestScripter's test class. Allowed result can be defined

   287 //  with 'allownextresult' and 'allowerrorcodes' keywords.

   288 //  Example for use: T1L( Open(), KErrNone, KErrAlreadyExists, KErrDiskFull );

   289 //  =============================================================================

   290     #define TA3L( aResult, aExpected1, aExpected2, aExpected3 )\

   291         {\

   292         TInt result = aResult;\

   293         if( ( (result) != (aExpected1) && (result) != (aExpected2) && (result) != (aExpected3) ) && \

   294               TestModuleIf().CheckAllowResult( result ) )\

   295             { TestModuleIf().StifMacroError(\

   296                 (3), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), (aExpected1), (aExpected2), (aExpected3) );\

   297             User::Leave( KErrArgument ); };\

   298         };

   299 

   300 //  TA4L =======================================================================

   301 //  Macro for verify integer value from the expected 1, 2, 3 and 4 values.

   302 //  Recommended use with TestScripter's test class. Allowed result can be defined

   303 //  with 'allownextresult' and 'allowerrorcodes' keywords.

   304 //  Example for use:

   305 //  T1L( Open(), KErrNone, KErrAlreadyExists, KErrDiskFull, KErrDisconnected );

   306 //  =============================================================================

   307     #define TA4L( aResult, aExpected1, aExpected2, aExpected3, aExpected4 )\

   308         {\

   309         TInt result = aResult;\

   310         if( ( (result) != (aExpected1) && \

   311               (result) != (aExpected2) && \

   312               (result) != (aExpected3) && \

   313               (result) != (aExpected4) ) && \

   314                TestModuleIf().CheckAllowResult( result ) ) \

   315             { TestModuleIf().StifMacroError(\

   316                 (4), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), \

   317                 (aExpected1), (aExpected2), (aExpected3), (aExpected4) );\

   318             User::Leave( KErrArgument ); };\

   319         };

   320 

   321 //  TA5L =======================================================================

   322 //  Macro for verify integer value from the expected 1, 2, 3, 4 and 5 values.

   323 //  Recommended use with TestScripter's test class. Allowed result can be defined

   324 //  with 'allownextresult' and 'allowerrorcodes' keywords.

   325 //  Example for use:

   326 //  T1L( Open(), KErrNone, KErrDied, KErrInUse, KErrDisconnected, KErrAbort );

   327 //  =============================================================================

   328     #define TA5L( aResult, aExpected1, aExpected2, aExpected3, aExpected4, aExpected5 )\

   329         {\

   330         TInt result = aResult;\

   331         if( ( (result) != (aExpected1) && \

   332               (result) != (aExpected2) && \

   333               (result) != (aExpected3) && \

   334               (result) != (aExpected4) && \

   335               (result) != (aExpected5) ) && \

   336                TestModuleIf().CheckAllowResult( result ) ) \

   337             { TestModuleIf().StifMacroError(\

   338                 (5), (TText8*)__FILE__, __FUNCTION__, __LINE__, (result), \

   339                 (aExpected1), (aExpected2), (aExpected3), (aExpected4), (aExpected5) );\

   340             User::Leave( KErrArgument ); };\

   341         };

   342 

   343 

   344 // Workaround for ARM RVCT compiler error. This added because if some

   345 // environment do not include this definition.

   346 #if !defined (NONSHARABLE_CLASS)

   347 #define NONSHARABLE_CLASS(x) class x

   348 #endif

   349 

   350 // DATA TYPES

   351 // None

   352 

   353 // FUNCTION PROTOTYPES

   354 // None

   355 

   356 // FORWARD DECLARATIONS

   357 class CTestModuleBase;

   358 class TEventIf;

   359 class CTestThreadContainer;

   360 class MSTIFTestInterference;

   361 class CSTIFTestMeasurement;

   362 class CSTIFTestMeasurementImplementation;

   363 class CUiEnvProxy;

   364 

   365 // CLASS DECLARATION

   366 

   367 // DESCRIPTION

   368 // Base class for test case measurement . User can start measurement operations

   369 // via this class.

   370 NONSHARABLE_CLASS( CSTIFTestMeasurement )

   371         :public CBase 

   372     {

   373     public: // Enumerations

   374 

   375         /**

   376         * Enumeration for different measurement types.

   377         */

   378         enum TSTIFMeasurementType

   379             {

   380             KStifMeasurementEnableAll,

   381             KStifMeasurementPlugin01,

   382             KStifMeasurementPlugin02,

   383             KStifMeasurementPlugin03,

   384             KStifMeasurementPlugin04,

   385             KStifMeasurementPlugin05,

   386             KStifMeasurementBappeaProfiler,

   387             KStifMeasurementDisableAll,

   388             };

   389 

   390         /**

   391         * Enumeration for different measurement operations.

   392         */

   393         enum TSTIFMeasurementOperation

   394             {

   395             KMeasurementNew,

   396             KMeasurementStart,

   397             KMeasurementStop,

   398             };

   399 

   400         /**

   401         * Struct for measurement.

   402         */

   403         struct TStifMeasurementStruct

   404             {

   405             TSTIFMeasurementType        iMeasurementType;

   406             TFileName                   iConfigurationInfo;

   407             TSTIFMeasurementOperation   iMeasurementOperation;

   408             TInt                        iOperationResult;

   409             CTestModuleBase*            iPointerToMeasurementModule;

   410             };

   411 

   412     private: // Enumerations

   413 

   414     public: // Constructors and destructor

   415 

   416         /**

   417         * Two-phased constructor. Intializes test measurement module.

   418         */

   419         IMPORT_C static CSTIFTestMeasurement* NewL( 

   420                                             CTestModuleBase* aTestModuleBase,

   421                                             TSTIFMeasurementType aType,

   422                                             const TDesC& aConfigurationInfo );

   423 

   424     public: // New functions

   425 

   426         /**

   427         * Start commant for test measurement module.

   428         * Returns Symbian error code.

   429         */

   430         IMPORT_C TInt Start();

   431 

   432         /**

   433         * Stop command for test measurement module.

   434         * Returns Symbian error code.

   435         */

   436         IMPORT_C TInt Stop();

   437 

   438     public: // Functions from base classes

   439 

   440         /**

   441         * Destructor 

   442         */

   443         virtual ~CSTIFTestMeasurement();

   444 

   445     protected: // New functions

   446 

   447     protected: // Functions from base classes

   448 

   449     private:

   450 

   451         /**

   452         * C++ default constructor.

   453         */

   454         CSTIFTestMeasurement( CTestModuleBase* aTestModuleBase );

   455 

   456         /**

   457         * By default Symbian OS constructor is private.

   458         */

   459         void ConstructL( TSTIFMeasurementType aType,

   460                          const TDesC& aConfigurationInfo );

   461 

   462     public: //Data

   463 

   464     protected: // Data

   465 

   466     private: // Data

   467 

   468         // Pointer to STIF side

   469         CTestModuleBase*        iTestModuleBase;

   470 

   471         // Stuct that includes measurement related information

   472         TStifMeasurementStruct  iMeasurementStruct;

   473 

   474         // Indicates is measurement disable

   475         TInt                    iMeasurementOption;

   476 

   477     public: // Friend classes

   478 

   479     protected: // Friend classes

   480 

   481     private: // Friend classes

   482         friend class CTestModuleBase;

   483 

   484     };

   485 

   486 

   487 // CLASS DECLARATION

   488 

   489 // DESCRIPTION

   490 // TTestResult defines the test case result information.

   491 class TTestResult 

   492     {

   493     public:

   494 

   495         /**

   496         * Default constructor of TTestResult.

   497         */

   498         IMPORT_C TTestResult();

   499 

   500         /**

   501         * Sets result and result description of the test case.

   502         */

   503         IMPORT_C void SetResult( TInt aResultCode, const TDesC& aResultDes );

   504 

   505     public:

   506 

   507         // Test case result as Symbian OS error code.

   508         TInt iResult;

   509         // Descriptive test case result.

   510         TResultDes iResultDes;

   511     };

   512 

   513 // CLASS DECLARATION

   514 

   515 // DESCRIPTION

   516 // TTestCaseInfo defines the information for test case execution.

   517 class TTestCaseInfo

   518     {

   519     public:

   520         // Default test case priority values

   521         enum TPriority

   522             {    

   523             EPriorityLow = -100,

   524             EPriorityNormal = 0,

   525             EPriorityHigh = 100,

   526             };

   527 

   528     public:

   529 

   530         /**

   531         * Default constructor of TTestCaseInfo.

   532         */

   533         IMPORT_C TTestCaseInfo();

   534 

   535     public:

   536 

   537         // Test case number.

   538         TInt iCaseNumber;

   539         // Test case title.

   540         TName iTitle;

   541         // Test Case Timeout ( 0 == No timeout )

   542         TTimeIntervalMicroSeconds iTimeout; 

   543         // Test case priority

   544         TInt iPriority;

   545 

   546     };

   547 // Packaged TTestCaseInfo

   548 typedef TPckg<TTestCaseInfo> TTestCaseInfoPckg;

   549 

   550 // CLASS DECLARATION

   551 

   552 // DESCRIPTION

   553 // CTestModuleIf provides interface for Test Module to perform 

   554 // printing to user interface and to control event system.

   555 class CTestModuleIf

   556         :public CBase 

   557     {

   558     public: // Enumerations

   559 

   560         // Possible test case exit reasons.

   561         enum TExitReason

   562             {    

   563             // Case will exit normally AND return test case result.

   564             ENormal,          

   565             // Case is expected to panic.

   566             EPanic,           

   567             // Case will end to exception.

   568             EException,

   569             };

   570 

   571         enum TRebootType

   572             {

   573             EDefaultReset = 0,  // Do not change the value

   574             EKernelReset,

   575 

   576             EDeviceReset0 = 100,

   577             EDeviceReset1,

   578             EDeviceReset2,

   579             EDeviceReset3,

   580             EDeviceReset4,

   581             EDeviceReset5

   582             };

   583 

   584         enum TTestBehavior

   585             {

   586             ETestLeaksMem       = 0x00000001,

   587             ETestLeaksRequests  = 0x00000002,

   588             ETestLeaksHandles   = 0x00000004,

   589             EOOMDisableLeakChecks = 0x00000008,

   590             };

   591 

   592     private: // Enumerations

   593 

   594     public: // Constructors and destructor

   595 

   596         /**

   597         * Two-phased constructor.

   598         */

   599         IMPORT_C static CTestModuleIf* NewL( CTestThreadContainer* aExecutionSession, 

   600                                              CTestModuleBase* aTestModule );

   601 

   602     public: // New functions

   603 

   604         /**

   605         * Printf is used to provide different information up to the UI 

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

   607         * The definition of data to be printed is copied to aDefinition. 

   608         * The aPriority tells how important information is returned. 

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

   610         * received from the Test Module will be discarded or not in 

   611         * the different performance situations. The priority is also 

   612         * used in the Test Module server and in the Test Engine to queue 

   613         * the Printf responses.

   614         * This method is implemented in Test Module Server and the Test Module 

   615         * can call it to provide printable information to the UI.

   616         */

   617         IMPORT_C void Printf( const TInt aPriority, 

   618                               const TDesC& aDefinition, 

   619                               TRefByValue<const TDesC> aFmt,... );

   620 

   621         /**

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

   623         * TEvent &aEvent encapsulates the request type and 

   624         * the event name, see StifTestEventInterface.h for more information.

   625         * This method is implemented in Test Module Server and the Test Module 

   626         * can call it to control the event system.

   627         */

   628         IMPORT_C TInt Event( TEventIf& aEvent );

   629 

   630         /**

   631         * Asynchronous overload function for the previous. Only one 

   632         * asynchronous Event call can be active concurrently. Second 

   633         * concurrent call will block until first one is completed.

   634         */

   635         IMPORT_C void Event( TEventIf& aEvent, TRequestStatus& aStatus );

   636 

   637         /**

   638         * Cancel asynchronous event command. 

   639         */

   640         IMPORT_C TInt CancelEvent( TEventIf& aEvent,

   641                                    TRequestStatus* aStatus );

   642 

   643         /**

   644         * SetExitReason function is used to set different crash reasons to

   645         * acceptable test case result. 

   646         * Only one exit reason can be set at time. When function is called

   647         * again, previous exit reason is removed and new one is set to

   648         * acceptable exit reason.

   649         *

   650         * Function is typically used to accept test case panics as "passed"

   651         * test cases.

   652         * 

   653         * Test case that panics or gets exception is set to passed 

   654         * if aExitReason parameter matches with exit reason and 

   655         * aExitCode matches with panic code or exception type.

   656         */

   657         IMPORT_C void SetExitReason( const CTestModuleIf::TExitReason aExitReason, 

   658                                      const TInt aExitCode );

   659 

   660 

   661         /**

   662         * RemoteSend function is used send remote control protocol messages.

   663         */

   664         IMPORT_C TInt RemoteSend( const TDesC& aRemoteMsg );

   665 

   666         /**

   667         * RemoteReceive function is used receive remote 

   668         * control protocol messages.

   669         */

   670         IMPORT_C void RemoteReceive( TDes& aRemoteMsg, 

   671                                      TRequestStatus& aStatus );

   672 

   673         /**

   674         * RemoteReceiveCancel function is used cancel 

   675         * pending RemoteReceive.

   676         */

   677         IMPORT_C void RemoteReceiveCancel();

   678 

   679         /**

   680         * Reboot device, StoreState MUST have been called.

   681         */

   682         IMPORT_C TInt Reboot( TInt aType = EDefaultReset );

   683 

   684         /**

   685         * Store state before reboot. MUST be called before calling Reboot().

   686         */

   687         IMPORT_C TInt StoreState( TInt aCode, TName& aName );

   688 

   689         /**

   690         * Get state after reboot (stored with StoreState).

   691         */

   692         IMPORT_C TInt GetStoredState( TInt& aCode, TName& aName );

   693 

   694         /**

   695         * Set test case behavior, e.g. allow memory leak, handle leak etc.

   696         */

   697         IMPORT_C TInt SetBehavior( TTestBehavior aType, TAny* aPtr=NULL );

   698 

   699         /**

   700         * This can be called from test module but it is recommended to use

   701         * TL, T1L, T2L or T3L macro instead of this method.

   702         * For more information see macro definitions above on this file.

   703         */ 

   704         IMPORT_C TInt StifMacroError( TInt aMacroType,

   705                                       const TText8* aFile,

   706                                       const char* aFunction,

   707                                       TInt aLine,

   708                                       TInt aResult = 0,

   709                                       TInt aExpected1 = 0,

   710                                       TInt aExpected2 = 0,

   711                                       TInt aExpected3 = 0,

   712                                       TInt aExpected4 = 0,

   713                                       TInt aExpected5 = 0 );

   714 

   715         /**

   716         * Add thread handle to Array. Via array can handle test interference

   717         * thread's kill in panic etc. cases

   718         */ 

   719         TInt AddInterferenceThread( RThread aSTIFTestInterference );

   720 

   721         /**

   722         * Remove thread handle from Array.Test interference thread is stopped

   723         * and killed successfully

   724         */ 

   725         TInt RemoveInterferenceThread( RThread aSTIFTestInterference );

   726 

   727         /**

   728         * With this can be stored information about test measurement

   729         * to TestServer space.

   730         */ 

   731         TInt HandleMeasurementProcess( CSTIFTestMeasurement::TStifMeasurementStruct aSTIFMeasurementInfo );

   732 

   733         /**

   734         * Get measurement option(s) given from initialization file etc.

   735         */

   736         IMPORT_C TInt GetMeasurementOptions( TInt& aOptions );

   737 

   738         /**

   739         * Use with TAL, TA1L, TA2L, TA3L, TA4L and TA5L macros to allow

   740         * results.

   741         * Set test case allow result given by user. In TestScripter cases allow

   742         * result can set by 'allownextresult' or 'allowerrorcodes' keywords. In

   743         * Normal and Hardcoded test modules allow result can be set with this

   744         * method, reset should be done with ResetAllowResult method.

   745         */

   746         IMPORT_C TInt SetAllowResult( TInt aResult );

   747 

   748         /**

   749         * This is mainly used by STIF's TAL-TA5L macros internally.

   750         * Check is macros result allowed result.

   751         */

   752         IMPORT_C TInt CheckAllowResult( TInt aResult );

   753 

   754         /**

   755         * Use with TAL, TA1L, TA2L, TA3L, TA4L and TA5L macros to reset allowed

   756         * results.

   757         * Reset allow result(s) given with SetAllowResult. In TestScripter

   758         * cases this will be called automatically by STIF. Normal and Hardcoded

   759         * cases this should be called by user.

   760         */

   761         IMPORT_C TInt ResetAllowResult();

   762 

   763         /**

   764         * StopExecution function is used to stop the execution of test case.

   765         */

   766         IMPORT_C TInt StopExecution(TStopExecutionType aType, TInt aCode = KErrNone);

   767 

   768         /**

   769          * SendTestModuleVersion method is used to pass version of test module

   770          * to test engine

   771          */

   772         IMPORT_C TInt SendTestModuleVersion(TVersion aVersion, TFileName aModuleName);

   773         

   774         /**

   775          * SendTestModuleVersion method is used to pass version of test module

   776          * to test engine. This version with 3 parameters were added because version with

   777          * 2 parameters has arguments passed by value which is incorrect. So the third argument

   778          * was added only to overload the method and enable test modules using "old" version

   779          * (with 2 parameters) to work. Only this version (with three parameters) should be used.

   780          */

   781         IMPORT_C TInt SendTestModuleVersion(TVersion& aVersion, const TDesC& aModuleName, TBool aNewVersion);

   782 

   783         /**

   784         * Command function is used to send command to test engine.

   785         * It was created to provide possibility to kill test case by itself.

   786         */

   787         TInt Command(TCommand aCommand, const TDesC8& aParamsPckg);

   788 

   789         /**

   790          * Get test case execution arguments

   791          */

   792         IMPORT_C const TDesC& GetTestCaseArguments() const;        

   793 

   794         /**

   795         * GetTestCaseTitleL function is used to obtain test case title.

   796         */

   797         IMPORT_C void GetTestCaseTitleL(TDes& aTestCaseTitle);

   798 

   799         /**

   800         * Checks if testserver supports UI testing

   801         */

   802 		IMPORT_C TBool UITesting();

   803 

   804         /**

   805         * Gets UIEnvProxy

   806         */

   807 		IMPORT_C CUiEnvProxy* GetUiEnvProxy();

   808 

   809     public: // Functions from base classes

   810 

   811     protected: // New functions

   812 

   813     protected: // Functions from base classes

   814 

   815     private:

   816 

   817         /**

   818         * C++ default constructor.

   819         */

   820         CTestModuleIf( CTestThreadContainer* aTestExecution );

   821 

   822         /**

   823         * By default Symbian OS constructor is private.

   824         */

   825         void ConstructL( CTestModuleBase* aTestModule );

   826 

   827         /**

   828         * Destructor is also private. 

   829         * ONLY friend CTestModuleBase can delete CTestModuleIf.

   830         */

   831         ~CTestModuleIf();

   832 

   833         /**

   834         * Check that server is alive.

   835         */ 

   836         TBool IsServerAlive();

   837 

   838     public: //Data

   839 

   840     protected: // Data

   841 

   842     private: // Data

   843         CTestThreadContainer* iTestExecution;

   844 

   845         // Indicates is reboot operation ready to start.

   846         TBool iIsRebootReady;

   847 

   848         // Indicated StoreState() method's call times.

   849         TInt iStoreStateCounter;

   850 

   851         // Test case allowed results. Array is a static one for avoid dynamic

   852         // allocations.

   853         TInt iTestCaseResults[KSTIFMacroResultArraySize]; 

   854         // Test case allowed results count. This is used with

   855         // iTestCaseResults array.

   856         TInt iAllowTestCaseResultsCount; 

   857 

   858     public: // Friend classes

   859 

   860     protected: // Friend classes

   861 

   862     private: // Friend classes

   863         friend class CTestModuleBase;

   864 

   865     };

   866 

   867 

   868 // CLASS DECLARATION

   869 

   870 // DESCRIPTION

   871 // Base class for test module parameters. According to parameters may

   872 // configure test module. e.g. heap and stack configuring.

   873 class CTestModuleParam : public CBase 

   874     {

   875 

   876     public: // Enumerations

   877 

   878         /**

   879         * Evolution version for test module parameters.

   880         **/

   881         enum TParameterVersio

   882             {

   883             EVersio1 = 1, // For heap and stack configuring.

   884             EVersio2 = 2, // For future needs.

   885             EVersio3 = 3, // For future needs.

   886             EVersio4 = 4, // For future needs.

   887             EVersio5 = 5, // For future needs.

   888 

   889             };

   890 

   891     private: // Enumerations

   892 

   893     public: // Constructors and destructor

   894 

   895         /**

   896         * Two-phased constructor.

   897         */

   898         //IMPORT_C static CTestModuleParam* NewL();

   899 

   900         /**

   901         *

   902         */

   903         //IMPORT_C ~CTestModuleParam();

   904 

   905     public: // New functions

   906 

   907         /**

   908         * 

   909         */

   910         virtual TInt Version() = 0;

   911 

   912     public: // Functions from base classes

   913 

   914     protected: // New functions

   915 

   916     protected: // Functions from base classes

   917 

   918     private:

   919 

   920         /**

   921         * C++ default constructor.

   922         */

   923         //CTestModuleParam();

   924 

   925         /**

   926         * By default Symbian OS constructor is private.

   927         */

   928         //void ConstructL();

   929 

   930     public: //Data

   931 

   932     protected: // Data

   933 

   934     private: // Data

   935 

   936     public: // Friend classes

   937 

   938     protected: // Friend classes

   939 

   940     private: // Friend classes

   941 

   942     };

   943 

   944 // CLASS DECLARATION

   945 

   946 // DESCRIPTION

   947 // CTestModuleParamVer01 implements evolution version 1 for test module's 

   948 // heap and stack configuring.

   949 class CTestModuleParamVer01 : public CTestModuleParam

   950     {

   951     public: // Enumerations

   952 

   953     private: // Enumerations

   954 

   955     public: // Constructors and destructor

   956 

   957         /**

   958         * Two-phased constructor.

   959         */

   960         IMPORT_C static CTestModuleParamVer01* NewL();

   961         //IMPORT_C CTestModuleParamVer01* NewL();

   962 

   963         /**

   964         * C++ default constructor.

   965         */

   966         CTestModuleParamVer01();

   967 

   968         /**

   969         * Destructor.

   970         */

   971         IMPORT_C ~CTestModuleParamVer01(); 

   972 

   973     private: // Constructors and destructor

   974 

   975         /**

   976         * By default Symbian OS constructor is private.

   977         */

   978         void ConstructL();

   979 

   980     public: // New functions

   981 

   982         /**

   983         *

   984         */

   985         inline TInt Version() { return iVersio; };

   986 

   987     public: // Functions from base classes

   988         

   989     protected: // New functions

   990 

   991     protected: // Functions from base classes

   992 

   993     private:

   994 

   995     public: // Data

   996 

   997         /**

   998         * Test thread stack size defined by user.

   999         **/

  1000         TInt iTestThreadStackSize;

  1001 

  1002         /**

  1003         * Test thread heap minimum size defined by user.

  1004         **/

  1005         TInt iTestThreadMinHeap;

  1006 

  1007         /**

  1008         * Test thread heap maximum size defined by user.

  1009         **/

  1010         TInt iTestThreadMaxHeap;

  1011 

  1012     protected: // Data

  1013 

  1014     private: // Data

  1015 

  1016         /**

  1017         *

  1018         **/

  1019         TInt iVersio;

  1020 

  1021     public: // Friend classes

  1022 

  1023     protected: // Friend classes

  1024 

  1025     private: // Friend classes

  1026 

  1027     };

  1028 

  1029 // CLASS DECLARATION

  1030 

  1031 // DESCRIPTION

  1032 // Test Module inherits the CTestModuleBase class that is used to provide 

  1033 // simple interface between Test Engine and Test Module. CTestModuleBase 

  1034 // consists of pure virtual methods that the Test Module shall implement 

  1035 // and virtual methods that the Test Module should implement.

  1036 class CTestModuleBase

  1037         :public CBase

  1038     {

  1039     public: // Enumerations

  1040     

  1041         // For OOM execution

  1042         enum TOOMFailureType 

  1043             {    

  1044             EFailNext

  1045             };

  1046     private: // Enumerations

  1047 

  1048     public: // Version query.

  1049 

  1050         /**

  1051         * Returns the API version which this test module complies.

  1052         * Test Framework uses this function to verify that loaded module

  1053         * can be used in current framework release.

  1054         *

  1055         * Note that this function must always be the very first function

  1056         * that is defined in CTestModuleBase.

  1057         */

  1058         virtual inline TVersion Version()

  1059                                  { return TVersion ( KTestModuleAPIMajor,

  1060                                                      KTestModuleAPIMinor,

  1061                                                      KTestModuleAPIBuild); }

  1062 

  1063     public: // Constructors and destructor

  1064 

  1065         /**

  1066         * C++ default constructor.

  1067         */

  1068         CTestModuleBase(): iTestModuleIf(0) {};

  1069 

  1070         /**

  1071         * Destructor.

  1072         */

  1073         virtual ~CTestModuleBase(){ delete iTestModuleIf; }; 

  1074 

  1075     public: // New functions

  1076 

  1077         /**

  1078         * InitL is used to initialize the Test Module. The Test Modules may 

  1079         * use the initialization file to read parameters for Test Module 

  1080         * initialization but they can also have their own configure file or 

  1081         * some other routine to initialize themselves.

  1082         * This method is virtual and it is not mandatory to implement it 

  1083         * to Test Module.

  1084         */

  1085         virtual TInt InitL( TFileName& /* aIniFile */,

  1086                            TBool /* aFirstTime */ )

  1087             { return KErrNone; };

  1088 

  1089         /**

  1090         * Test cases are inquired from the Test Module by calling 

  1091         * GetTestCasesL. Test cases may be read from the testcase file 

  1092         * specified by aTestCaseFile or they can be e.g. hardcoded to testmodule. 

  1093         * If the Test Module does not use testcase files for test case 

  1094         * definition it does not use aTestCaseFile parameter. Test cases are 

  1095         * appended to RPointerArray<TTestCaseInfo> that is a list 

  1096         * consisting of several TTestCaseInfo objects.

  1097         * The STIF Test Framework will be the owner of the objects stored to 

  1098         * RPointerArray after the GetTestCasesL has appended them to the list

  1099         * and it does the memory deallocation.

  1100         * This method is pure virtual and the Test Module must implement it.

  1101         */

  1102         virtual TInt GetTestCasesL( const TFileName& aTestCaseFile, 

  1103             RPointerArray<TTestCaseInfo>& aTestCases ) = 0;

  1104 

  1105         /**

  1106         * RunTestCaseL is used to run an individual test case specified 

  1107         * by aCaseNumber and aTestCaseFile (optional). 

  1108         * This method is synchronous and test case result is returned as 

  1109         * reference parameter aResult value. 

  1110         * The function shall return KErrNone if case is started succesfully.

  1111         * If test case is not available (i.e invalid testcase file or

  1112         * or case number), then function shall return KErrNotFound. In other 

  1113         * error situations another Symbian error code is returned.                

  1114         * This method is pure virtual and the Test Module must implement it. 

  1115         */

  1116         virtual TInt RunTestCaseL( const TInt aCaseNumber, 

  1117                                   const TFileName& aTestCaseFile,

  1118                                   TTestResult& aResult ) = 0;

  1119 

  1120         /**

  1121         * TestModuleIf returns the handle to the CTestModuleIf interface. 

  1122         * This is an utility function that can be used if the upper layer 

  1123         * interface is needed to be used.

  1124         * This method must not be called from the constructor of Test Module 

  1125         * that derives the CTestModuleBase.

  1126         */

  1127         inline CTestModuleIf& TestModuleIf(){ return *iTestModuleIf; };

  1128 

  1129         /**

  1130         * Used to perform the test environment setup for a particular OOM test 

  1131         * case. The Test Modules may use the initialization file to read parameters 

  1132         * for Test Module initialization but they can also have their own 

  1133         * configure file or some other routine to initialize themselves.

  1134         *

  1135         * This method is virtual and will be implemented if test case is to be