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 module contains the implementation of 

    15 * MSTIFTestInterference class member functions.

    16 *

    17 */

    18 

    19 // INCLUDE FILES

    20 #include <StifTestInterference.h>

    21 #include "TestInterferenceImplementation.h"

    22 

    23 // EXTERNAL DATA STRUCTURES

    24 //extern  ?external_data;

    25 

    26 // EXTERNAL FUNCTION PROTOTYPES  

    27 //extern ?external_function( ?arg_type,?arg_type );

    28 

    29 // CONSTANTS

    30 //const ?type ?constant_var = ?constant;

    31 

    32 // For test interference thread's heap size

    33 const TUint KMaxHeapSize        = 0x20000; // 128 K

    34 

    35 // MACROS

    36 //#define ?macro ?macro_def

    37 

    38 // LOCAL CONSTANTS AND MACROS

    39 //const ?type ?constant_var = ?constant;

    40 //#define ?macro_name ?macro_def

    41 

    42 // MODULE DATA STRUCTURES

    43 //enum ?declaration

    44 //typedef ?declaration

    45 

    46 // LOCAL FUNCTION PROTOTYPES

    47 //?type ?function_name( ?arg_type, ?arg_type );

    48 

    49 // FORWARD DECLARATIONS

    50 //class ?FORWARD_CLASSNAME;

    51 

    52 // ============================= LOCAL FUNCTIONS ===============================

    53 

    54 // -----------------------------------------------------------------------------

    55 // ?function_name ?description.

    56 // ?description

    57 // Returns: ?value_1: ?description

    58 //          ?value_n: ?description_line1

    59 //                    ?description_line2

    60 // -----------------------------------------------------------------------------

    61 //

    62 /*

    63 ?type ?function_name(

    64     ?arg_type arg,  // ?description

    65     ?arg_type arg)  // ?description

    66     {

    67 

    68     ?code  // ?comment

    69 

    70     // ?comment

    71     ?code

    72     }

    73 */

    74 

    75 // ============================ MEMBER FUNCTIONS ===============================

    76 

    77 /*

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

    79 

    80     Class: MSTIFTestInterference

    81 

    82     Method: MSTIFTestInterference

    83 

    84     Description: Create test interference object according to the paramater.

    85 

    86     Parameters: CTestModuleBase* aTestModuleBase: inout: CTestModuleBase object

    87                 for get test interference handle to STIF's side(Used if test

    88                 case panic so test interference thread can be kill by STIF).

    89                 TStifTestInterferenceCategory aCategory: in: Test interference

    90                 category

    91 

    92     Return Values: MSTIFTestInterference*: pointer to MSTIFTestInterference 

    93                    object

    94 

    95     Errors/Exceptions: Leaves if object creation fails.

    96 

    97     Status: Approved

    98 

    99 -------------------------------------------------------------------------------

   100 */

   101 EXPORT_C MSTIFTestInterference* MSTIFTestInterference::NewL(

   102                                     CTestModuleBase* aTestModuleBase,

   103                                     TStifTestInterferenceCategory aCategory )

   104     {

   105     if( aCategory == EActiveObject )        // Active object

   106         {

   107         CSTIFInterferenceAO* self = NULL;

   108         self = CSTIFInterferenceAO::NewL();

   109         return (MSTIFTestInterference*)self;

   110         }

   111     else                                    // EThread

   112         {

   113         CSTIFInterferenceThread* self = NULL;

   114         self = CSTIFInterferenceThread::NewL( aTestModuleBase );

   115         return (MSTIFTestInterference*)self;

   116         }

   117 

   118     }

   119 

   120 /*

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

   122 

   123     Class: MSTIFTestInterference

   124 

   125     Method: MSTIFTestInterference

   126 

   127     Description: Destructor

   128 

   129     Parameters: None

   130 

   131     Return Values: None

   132 

   133     Errors/Exceptions: None

   134 

   135     Status: Approved

   136 

   137 -------------------------------------------------------------------------------

   138 */

   139 MSTIFTestInterference::~MSTIFTestInterference()

   140     {

   141     // None

   142 

   143     }

   144 

   145 /*

   146 -------------------------------------------------------------------------------

   147 

   148     DESCRIPTION

   149 

   150     This module contains the implementation of CSTIFInterferenceAO class 

   151     member functions.

   152 

   153 -------------------------------------------------------------------------------

   154 */

   155 

   156 // ============================ MEMBER FUNCTIONS ===============================

   157 

   158 /*

   159 -------------------------------------------------------------------------------

   160 

   161     Class: CSTIFInterferenceAO

   162 

   163     Method: CSTIFInterferenceAO

   164 

   165     Description: C++ default constructor can NOT contain any code, that

   166                  might leave 

   167 

   168     Parameters: None

   169 

   170     Return Values: None

   171 

   172     Errors/Exceptions: None

   173 

   174     Status: Approved

   175 

   176 -------------------------------------------------------------------------------

   177 */

   178 CSTIFInterferenceAO::CSTIFInterferenceAO() :

   179                                     CActive ( CActive::EPriorityStandard )

   180     {

   181     iInterferenceType = ENone;

   182     iIdleTime = 0;

   183     iActiveTime = 0;

   184     iExecuteInterference = NULL;

   185 

   186     }

   187 

   188 /*

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

   190 

   191     Class: CSTIFInterferenceAO

   192 

   193     Method: ConstructL

   194 

   195     Description: Symbian 2nd phase constructor can leave.

   196 

   197     Parameters: None

   198 

   199     Return Values: None

   200 

   201     Errors/Exceptions: Leave if CreateLocal fails

   202 

   203     Status: Approved

   204 

   205 -------------------------------------------------------------------------------

   206 */

   207 void CSTIFInterferenceAO::ConstructL()

   208     {

   209     CActiveScheduler::Add ( this );

   210 

   211     User::LeaveIfError( iAOIdleTimer.CreateLocal() );

   212 

   213     iExecuteInterference = CExecuteInterference::NewL();

   214 

   215     }

   216 

   217 /*

   218 -------------------------------------------------------------------------------

   219 

   220     Class: CSTIFInterferenceAO

   221 

   222     Method: NewL

   223 

   224     Description: Two-phased constructor.

   225 

   226     Parameters: None

   227 

   228     Return Values: CSTIFInterferenceAO*: pointer to CSTIFInterferenceAO object

   229 

   230     Errors/Exceptions: Leaves if object creation fails.

   231 

   232     Status: Approved

   233 

   234 -------------------------------------------------------------------------------

   235 */

   236 CSTIFInterferenceAO* CSTIFInterferenceAO::NewL()

   237     {

   238     CSTIFInterferenceAO* self = new (ELeave) CSTIFInterferenceAO();

   239 

   240     CleanupStack::PushL( self );

   241     self->ConstructL();

   242     CleanupStack::Pop();

   243 

   244     return self;

   245 

   246     }

   247 

   248 /*

   249 -------------------------------------------------------------------------------

   250 

   251     Class: CSTIFInterferenceAO

   252 

   253     Method: ~CSTIFInterferenceAO

   254 

   255     Description: Destructor.

   256 

   257     Parameters: None

   258 

   259     Return Values: None

   260 

   261     Errors/Exceptions: None

   262 

   263     Status: Approved

   264 

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

   266 */

   267 CSTIFInterferenceAO::~CSTIFInterferenceAO()

   268     {

   269     Cancel(); // Cancel itself

   270     // If test case panic etc. do close operations here.

   271     delete iExecuteInterference;

   272     iExecuteInterference = NULL;

   273 

   274     iAOIdleTimer.Close();

   275 

   276     }

   277 

   278 /*

   279 -------------------------------------------------------------------------------

   280 

   281     Class: CSTIFInterferenceAO

   282 

   283     Method: RunL

   284 

   285     Description: Derived from CActive, handles test interference execution.

   286 

   287     Parameters: None

   288 

   289     Return Values: None

   290 

   291     Errors/Exceptions: Leaves if InterferenceL leaves.

   292 

   293     Status: Approved

   294 

   295 -------------------------------------------------------------------------------

   296 */

   297 void CSTIFInterferenceAO::RunL( )

   298     {

   299     iExecuteInterference->InterferenceL( iInterferenceType, iActiveTime );

   300     

   301     // Start idle timer

   302     iAOIdleTimer.After( iStatus, iIdleTime );

   303     SetActive();

   304 

   305     }

   306 

   307 /*

   308 -------------------------------------------------------------------------------

   309 

   310     Class: CSTIFInterferenceAO

   311 

   312     Method: DoCancel

   313 

   314     Description: Derived from CActive handles the Cancel

   315 

   316     Parameters: None

   317 

   318     Return Values: None

   319 

   320     Errors/Exceptions: None

   321 

   322     Status: Approved

   323 

   324 -------------------------------------------------------------------------------

   325 */

   326 void CSTIFInterferenceAO::DoCancel( )

   327     {

   328     iAOIdleTimer.Cancel();

   329 

   330     }

   331 

   332 /*

   333 -------------------------------------------------------------------------------

   334 

   335     Class: CSTIFInterferenceAO

   336 

   337     Method: RunError

   338 

   339     Description: Derived from CActive handles errors from active handler.

   340 

   341     Parameters: TInt aError: in: error from CActive 

   342 

   343     Return Values: TInt: Symbian error code

   344 

   345     Errors/Exceptions: None

   346 

   347     Status: Approved

   348 

   349 -------------------------------------------------------------------------------

   350 */

   351 TInt CSTIFInterferenceAO::RunError( TInt aError )

   352     {

   353     RDebug::Print( _L( "CSTIFInterferenceAO::RunError() with [%d]" ), aError );

   354 

   355     return aError;

   356 

   357     }

   358 

   359 /*

   360 -------------------------------------------------------------------------------

   361 

   362     Class: CSTIFInterferenceAO

   363 

   364     Method: StartL

   365 

   366     Description: StartL method starts test interference.

   367 

   368     Parameters: TStifTestInterferenceType aType: in: Test interference type.

   369                 TInt aIdleTime: in: Test interference idle time.

   370                 TInt aActiveTime: in: Test interference active time.

   371 

   372     Return Values: TInt: Symbian error code.

   373 

   374     Errors/Exceptions: Leaves if active object is active.

   375 

   376     Status: Approved

   377 

   378 -------------------------------------------------------------------------------

   379 */

   380 TInt CSTIFInterferenceAO::StartL( TStifTestInterferenceType aType,

   381                                     TInt aIdleTime,

   382                                     TInt aActiveTime )

   383     {

   384     if( IsActive() )

   385         {

   386         User::Leave( KErrAlreadyExists );

   387         }

   388 

   389     switch( aType )

   390     	{

   391     	case ENone:

   392     	case ECpuLoad:

   393     	case EFileSystemReadC:

   394     	case EFileSystemReadD:

   395     	case EFileSystemReadE:

   396     	case EFileSystemReadZ:

   397     	case EFileSystemWriteC:

   398     	case EFileSystemWriteD:

   399     	case EFileSystemWriteE:

   400     	case EFileSystemFillAndEmptyC:

   401     	case EFileSystemFillAndEmptyD:

   402     	case EFileSystemFillAndEmptyE:

   403     		aIdleTime = aIdleTime * 1000;

   404     		aActiveTime = aActiveTime * 1000;

   405     		break;

   406     	case ENoneMicroSeconds:

   407     		aType = ENone;

   408     		break;

   409     	case ECpuLoadMicroSeconds:

   410 			aType = ECpuLoad;

   411 			break;

   412     	case EFileSystemReadCMicroSeconds:

   413 			aType = EFileSystemReadC;

   414 			break;

   415     	case EFileSystemReadDMicroSeconds:

   416 			aType = EFileSystemReadD;

   417 			break;

   418     	case EFileSystemReadEMicroSeconds:

   419 			aType = EFileSystemReadE;

   420 			break;

   421     	case EFileSystemReadZMicroSeconds:

   422 			aType = EFileSystemReadZ;

   423 			break;

   424     	case EFileSystemWriteCMicroSeconds:

   425 			aType = EFileSystemWriteC;

   426 			break;

   427     	case EFileSystemWriteDMicroSeconds:

   428 			aType = EFileSystemWriteD;

   429 			break;

   430     	case EFileSystemWriteEMicroSeconds:

   431 			aType = EFileSystemWriteE;

   432 			break;

   433     	case EFileSystemFillAndEmptyCMicroSeconds:

   434 			aType = EFileSystemFillAndEmptyC;

   435 			break;

   436     	case EFileSystemFillAndEmptyDMicroSeconds:

   437 			aType = EFileSystemFillAndEmptyD;

   438 			break;

   439     	case EFileSystemFillAndEmptyEMicroSeconds:

   440 			aType = EFileSystemFillAndEmptyE;

   441 			break;

   442     	}    

   443     

   444     iInterferenceType = aType;

   445     iIdleTime = aIdleTime;

   446     iActiveTime = aActiveTime;

   447 

   448     // Set request to pending and active object to active

   449     iStatus = KRequestPending;

   450     SetActive();

   451     // Complete request immediately

   452     TRequestStatus* status = &iStatus;

   453     User::RequestComplete( status, KErrNone );

   454 

   455     return KErrNone;

   456 

   457     }

   458 

   459 /*

   460 -------------------------------------------------------------------------------

   461 

   462     Class: CSTIFInterferenceAO

   463 

   464     Method: Stop

   465 

   466     Description: Stop method stops test interference.

   467 

   468     Parameters: None

   469 

   470     Return Values: TInt: Symbian error code.

   471 

   472     Errors/Exceptions: None

   473 

   474     Status: Approved

   475 

   476 -------------------------------------------------------------------------------

   477 */

   478 TInt CSTIFInterferenceAO::Stop()

   479     {

   480     Cancel();

   481 

   482     return KErrNone;

   483 

   484     }

   485 

   486 /*

   487 -------------------------------------------------------------------------------

   488 

   489     Class: CSTIFInterferenceAO

   490 

   491     Method: SetPriority

   492 

   493     Description: Sets thread or active object priority. This should use before

   494                  test interference is started otherwise error code will return.

   495 

   496     Parameters: TInt aPriority: in: New priority for active object given by

   497                 user.

   498 

   499     Return Values: TInt: Symbian error code.

   500 

   501     Errors/Exceptions: None

   502 

   503     Status: Approved

   504 

   505 -------------------------------------------------------------------------------

   506 */

   507 TInt CSTIFInterferenceAO::SetPriority( TInt aPriority )

   508     {

   509     if( IsActive() )

   510         {

   511         RDebug::Print( _L( "STIF: Priority cannot set because active object is active" ) );

   512         return KErrGeneral;

   513         }

   514 

   515     CActive::SetPriority( (TPriority)aPriority );

   516 

   517     return KErrNone;

   518 

   519     }

   520 

   521 /*

   522 -------------------------------------------------------------------------------

   523 

   524     DESCRIPTION

   525 

   526     This module contains the implementation of CSTIFInterferenceThread class 

   527     member functions.

   528 

   529 -------------------------------------------------------------------------------

   530 */

   531 

   532 

   533 // ============================ MEMBER FUNCTIONS ===============================

   534 

   535 /*

   536 -------------------------------------------------------------------------------

   537 

   538     Class: CSTIFInterferenceThread

   539 

   540     Method: CSTIFInterferenceThread

   541 

   542     Description: C++ default constructor can NOT contain any code, that

   543                  might leave.

   544 

   545     Parameters: None

   546 

   547     Return Values: None

   548 

   549     Errors/Exceptions: None

   550 

   551     Status: Approved

   552 

   553 -------------------------------------------------------------------------------

   554 */

   555 CSTIFInterferenceThread::CSTIFInterferenceThread()

   556     {

   557     // None

   558 

   559     }

   560 

   561 /*

   562 -------------------------------------------------------------------------------

   563 

   564     Class: CSTIFInterferenceThread

   565 

   566     Method: ConstructL

   567 

   568     Description: C++ default constructor can NOT contain any code, that

   569                  might leave.

   570 

   571     Parameters: None

   572 

   573     Return Values: None

   574 

   575     Errors/Exceptions: None

   576 

   577     Status: Approved

   578 

   579 -------------------------------------------------------------------------------

   580 */

   581 void CSTIFInterferenceThread::ConstructL( CTestModuleBase* aTestModuleBase )

   582     {

   583     iTestModuleBase = aTestModuleBase;

   584 

   585     }

   586 

   587 /*

   588 -------------------------------------------------------------------------------

   589 

   590     Class: CSTIFInterferenceThread

   591 

   592     Method: NewL

   593 

   594     Description: Two-phased constructor.

   595 

   596     Parameters: None

   597 

   598     Return Values: CSTIFInterferenceThread*: pointer to CSTIFInterferenceThread

   599                    object

   600 

   601     Errors/Exceptions: Leaves if object creation fails.

   602 

   603     Status: Approved

   604 

   605 -------------------------------------------------------------------------------

   606 */

   607 CSTIFInterferenceThread* CSTIFInterferenceThread::NewL( 

   608                                             CTestModuleBase* aTestModuleBase )

   609     {

   610     CSTIFInterferenceThread* self = new (ELeave) CSTIFInterferenceThread();

   611 

   612     CleanupStack::PushL( self );

   613     self->ConstructL( aTestModuleBase );

   614     CleanupStack::Pop();

   615 

   616     return self;

   617 

   618     }

   619 

   620 /*

   621 -------------------------------------------------------------------------------

   622 

   623     Class: CSTIFInterferenceThread

   624 

   625     Method: ~CSTIFInterferenceThread

   626 

   627     Description: Destructor

   628 

   629     Parameters: None

   630 

   631     Return Values: None

   632 

   633     Errors/Exceptions: None

   634 

   635     Status: Approved

   636 

   637 -------------------------------------------------------------------------------

   638 */

   639 CSTIFInterferenceThread::~CSTIFInterferenceThread()

   640     {

   641     // If test case crash etc. do stop operations here also

   642     if( iThreadParam != NULL )

   643         {

   644         iThreadParam->iStarted.Close();

   645         }

   646     delete iThreadParam;

   647     iThreadParam = NULL;

   648     if( iThread.Handle() != NULL )

   649         {

   650         iThread.Kill( KErrNone );

   651         iThread.Close();

   652         }    

   653 

   654     }

   655 

   656 /*

   657 -------------------------------------------------------------------------------

   658 

   659     Class: CSTIFInterferenceThread

   660 

   661     Method: StartL

   662 

   663     Description: StartL method starts test interference.

   664 

   665     Parameters: TStifTestInterferenceType aType: in: Test interference type.

   666                 TInt aIdleTime: in: Test interference idle time.

   667                 TInt aActiveTime: in: Test interference active time.

   668 

   669     Return Values: TInt: Symbian error code.

   670 

   671     Errors/Exceptions: Leaves if iThreadParam exists.

   672                        Leaves if thread creation fails.

   673 

   674     Status: Approved

   675 

   676 -------------------------------------------------------------------------------

   677 */

   678 TInt CSTIFInterferenceThread::StartL( TStifTestInterferenceType aType,

   679                                         TInt aIdleTime,

   680                                         TInt aActiveTime )

   681     {

   682     //__UHEAP_MARK;

   683 

   684     if( iThreadParam )

   685         {

   686         User::Leave( KErrAlreadyExists );

   687         }

   688 

   689     // Thread related parameters

   690     iThreadParam = new TThreadParam;

   691     iThreadParam->iStarted.CreateLocal( 0 );

   692     iThreadParam->iType = aType;

   693     iThreadParam->iIdleTime = aIdleTime;

   694     iThreadParam->iActiveTime = aActiveTime;

   695 

   696     // Temporary thread unique name

   697     _LIT( KThreadFirstName, "STIFInterference_%x" );

   698      

   699     TBuf<32> tmpThreadName;

   700     TInt uniqueCounter = 1;

   701     

   702     TInt ret = KErrNone;

   703     do

   704     	{

   705     	tmpThreadName.Format( KThreadFirstName, uniqueCounter );

   706     	// Create thread

   707     	ret = iThread.Create(

   708     		    					tmpThreadName,       // thread name

   709     		                        ThreadFunction,         // thread function

   710     		                        KDefaultStackSize*4,    // stack

   711     		                        KMinHeapSize,           // Heap, min

   712     		                        KMaxHeapSize*2,         // Heap, max

   713     		                        (TAny*) iThreadParam    // parameter to thread function

   714     		                        );

   715     	uniqueCounter++;

   716     	}

   717     while( ret == KErrAlreadyExists );

   718     

   719     // If thread creation failed

   720     if( ret != KErrNone )        

   721         {

   722         iThreadParam->iStarted.Close();         // Close semaphore

   723         delete iThreadParam;

   724         iThreadParam = NULL;

   725         //__UHEAP_MARKEND;

   726         User::Leave( ret );

   727         }

   728 

   729     // Add thread pointer to STIF side for cases where need to kill

   730     // thread e.g. if test case is crashed etc. before Stop(give by user).

   731     iTestModuleBase->iTestModuleIf->AddInterferenceThread( iThread );

   732 

   733     // Create unique thread name

   734     const TInt name = 17; // Name parts

   735     const TInt id = 8;    // Unique id parts

   736     _LIT( KThreadUniqueName, "STIFInterference_" );

   737     TBuf<name+id> threadUniqueName;

   738     threadUniqueName.Copy( KThreadUniqueName );

   739     // Appends id in hexadesimal format 

   740     threadUniqueName.AppendFormat(  _L( "%x" ), (TInt)iThread.Id() );

   741     //RDebug::Print(threadUniqueName);

   742 

   743     // Reneme thread with unique name

   744     iThread.RenameMe( threadUniqueName );

   745 

   746     // Thread is currently in suspend state

   747 

   748     // Now start thread

   749     iThread.SetPriority( EPriorityMuchMore ); // set its priority

   750     iThread.Resume();                         // kick it into life in

   751                                               // sometimes(depend on scheduler)

   752 

   753     // This block execution here and continue when signal is said in thread

   754     // execution side.

   755     // Wait until the thread is started

   756     iThreadParam->iStarted.Wait();

   757 

   758     //__UHEAP_MARKEND;

   759 

   760     return KErrNone;

   761 

   762     }

   763 

   764 /*

   765 -------------------------------------------------------------------------------

   766 

   767     Class: CSTIFInterferenceThread

   768 

   769     Method: Stop

   770 

   771     Description:  Stop method stops test interference.

   772 

   773     Parameters: None

   774 

   775     Return Values: TInt: Symbian error code.

   776 

   777     Errors/Exceptions: None

   778 

   779     Status: Approved

   780 

   781 -------------------------------------------------------------------------------

   782 */

   783 TInt CSTIFInterferenceThread::Stop()

   784     {

   785     // Ensures that remove(Stop()) sequence won't do two times for one thread.

   786     if( iThread.Handle() != NULL )

   787         {

   788         // Remove pointer from array

   789         iTestModuleBase->iTestModuleIf->RemoveInterferenceThread( iThread );

   790         }

   791 

   792     // If test case crash etc. do stop operations here also

   793     if( iThreadParam != NULL )

   794         {

   795         iThreadParam->iStarted.Close();

   796         }

   797     delete iThreadParam;

   798     iThreadParam = NULL;

   799     if( iThread.Handle() != NULL )

   800         {

   801         iThread.Kill( KErrNone );

   802         iThread.Close();

   803         }    

   804 

   805     return KErrNone;

   806 

   807     }

   808 

   809 /*

   810 -------------------------------------------------------------------------------

   811 

   812     Class: CSTIFInterferenceThread

   813 

   814     Method: SetPriority

   815 

   816     Description: Sets thread or active object priority. This should use before

   817                  test interference is started otherwise error code will return.

   818 

   819     Parameters: TInt aPriority: in: New priority for active object given by

   820                 user.

   821 

   822     Return Values: TInt: Symbian error code.

   823 

   824     Errors/Exceptions: None

   825 

   826     Status: Approved

   827 

   828 -------------------------------------------------------------------------------

   829 */

   830 TInt CSTIFInterferenceThread::SetPriority( TInt aPriority )

   831     {

   832     // RThread priority can set during interference executions time. User

   833     // should be sure that given value is acceptable, otherwise SetPriority

   834     // panics.

   835 

   836     RThread thisThread;

   837     thisThread.SetPriority ( (TThreadPriority) aPriority );

   838 

   839     return KErrNone;

   840 

   841     }

   842 

   843 /*

   844 -------------------------------------------------------------------------------

   845 

   846     Class: CSTIFInterferenceThread

   847 

   848     Method: ThreadFunction

   849 

   850     Description: Implements thread code

   851 

   852     Parameters: TAny* aThreadArg: in : Thread related informations

   853 

   854     Return Values: TInt: Symbian error code.

   855 

   856     Errors/Exceptions: None

   857 

   858     Status: Approved

   859 

   860 -------------------------------------------------------------------------------

   861 */

   862 TInt CSTIFInterferenceThread::ThreadFunction( TAny* aThreadArg )

   863         {

   864         // Thread code here

   865 

   866         // Create clean-up stack

   867         CTrapCleanup* tc = CTrapCleanup::New();

   868 

   869         // Take local copy of incoming parameters. 

   870         // This object is in stack -> no manual deletion

   871         TThreadParam params = *(TThreadParam*)aThreadArg;

   872         

   873         // Signal to continue from CSTIFInterferenceThread::StartL

   874         params.iStarted.Signal();

   875 

   876         TInt ret = KErrNone;

   877 

   878         // Construct and install active scheduler

   879         CActiveScheduler* activeScheduler = new CActiveScheduler;

   880         CActiveScheduler::Install( activeScheduler );

   881 

   882         TRAP( ret, ExecuteInterferenceL( params.iType, params.iIdleTime, params.iActiveTime ) );

   883 

   884     	User::LeaveIfError( ret );

   885         

   886         delete activeScheduler;

   887         

   888         // Delete clean-up stack

   889         delete tc;

   890         tc = NULL;

   891 

   892         return KErrNone;

   893         }

   894 

   895 /*

   896 -------------------------------------------------------------------------------

   897 

   898     Class: CSTIFInterferenceThread

   899 

   900     Method: ExecuteInterferenceL

   901 

   902     Description: Executes interference.

   903 

   904     Parameters: aType		Interference type.

   905     			aIdleTime	Idle time.

   906     			aActiveTime Active time.

   907 

   908     Return Values: None

   909 

   910     Errors/Exceptions: None

   911 

   912     Status: Approved

   913 

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

   915 */

   916 void CSTIFInterferenceThread::ExecuteInterferenceL( TStifTestInterferenceType aType, TInt aIdleTime, TInt aActiveTime )

   917 	{

   918 	CSTIFInterferenceAO* interferenceAO = CSTIFInterferenceAO::NewL();

   919 	CleanupStack::PushL( interferenceAO );

   920 

   921 	interferenceAO->StartL( aType, aIdleTime, aActiveTime );

   922 

   923 	CActiveScheduler::Start();

   924 	

   925 	CleanupStack::PopAndDestroy( interferenceAO );

   926 	}

   927 

   928 /*

   929 -------------------------------------------------------------------------------

   930 

   931     DESCRIPTION

   932 

   933     This module contains the implementation of CExecuteInterference class 

   934     member functions.

   935 

   936 -------------------------------------------------------------------------------

   937 */

   938 

   939 

   940 // ============================ MEMBER FUNCTIONS ===============================

   941 

   942 /*

   943 -------------------------------------------------------------------------------

   944 

   945     Class: CExecuteInterference

   946 

   947     Method: CExecuteInterference

   948 

   949     Description: C++ default constructor can NOT contain any code, that

   950                  might leave.

   951 

   952     Parameters: None

   953 

   954     Return Values: None

   955 

   956     Errors/Exceptions: None

   957 

   958     Status: Approved

   959 

   960 -------------------------------------------------------------------------------

   961 */

   962 CExecuteInterference::CExecuteInterference()

   963     {

   964     iTimer.CreateLocal();

   965 

   966     }

   967 

   968 /*

   969 -------------------------------------------------------------------------------

   970 

   971     Class: CExecuteInterference

   972 

   973     Method: ConstructL

   974 

   975     Description: C++ default constructor can NOT contain any code, that

   976                  might leave.

   977 

   978     Parameters: None

   979 

   980     Return Values: None

   981 

   982     Errors/Exceptions: None

   983 

   984     Status: Approved

   985 

   986 -------------------------------------------------------------------------------

   987 */

   988 void CExecuteInterference::ConstructL()

   989     {

   990     // None

   991 

   992     }

   993 

   994 /*

   995 -------------------------------------------------------------------------------

   996 

   997     Class: CExecuteInterference

   998 

   999     Method: NewL

  1000 

  1001     Description: Two-phased constructor.

  1002 

  1003     Parameters: None

  1004 

  1005     Return Values: CExecuteInterference*: pointer to CExecuteInterference

  1006                    object

  1007 

  1008     Errors/Exceptions: Leaves if object creation fails.

  1009 

  1010     Status: Approved

  1011 

  1012 -------------------------------------------------------------------------------

  1013 */

  1014 CExecuteInterference* CExecuteInterference::NewL()

  1015     {

  1016     CExecuteInterference* self = new (ELeave) CExecuteInterference();

  1017 

  1018     CleanupStack::PushL( self );

  1019     self->ConstructL();

  1020     CleanupStack::Pop();

  1021 

  1022     return self;

  1023 

  1024     }

  1025 

  1026 /*

  1027 -------------------------------------------------------------------------------

  1028 

  1029     Class: CExecuteInterference

  1030 

  1031     Method: ~CExecuteInterference

  1032 

  1033     Description: Destructor

  1034 

  1035     Parameters: None

  1036 

  1037     Return Values: None

  1038 

  1039     Errors/Exceptions: None

  1040 

  1041     Status: Approved

  1042 

  1043 -------------------------------------------------------------------------------

  1044 */

  1045 CExecuteInterference::~CExecuteInterference()

  1046     {

  1047     iTimer.Cancel();

  1048     iTimer.Close();

  1049 

  1050     }

  1051 

  1052 /*

  1053 -------------------------------------------------------------------------------

  1054 

  1055     Class: CExecuteInterference

  1056 

  1057     Method: Interference

  1058 

  1059     Description: Start implement the test interference according to aType

  1060                  parameter.

  1061 

  1062     Parameters: MSTIFTestInterference::TStifTestInterferenceType aType: in:

  1063                     Test interference type.

  1064                 TInt aActiveTime: in: Test interference active time

  1065 

  1066     Return Values: TInt: Symbian error code

  1067 

  1068     Errors/Exceptions: Leaves if CleanupClosePushL leave

  1069 

  1070     Status: Proposal

  1071 

  1072 -------------------------------------------------------------------------------

  1073 */

  1074 TInt CExecuteInterference::InterferenceL( 

  1075                     MSTIFTestInterference::TStifTestInterferenceType aType,

  1076                     TInt aActiveTime )

  1077     {

  1078     TTimeIntervalMicroSeconds32 myActiveTime( aActiveTime );    

  1079     

  1080     TTime endTime;

  1081     endTime.HomeTime();           

  1082     endTime = endTime + myActiveTime;   

  1083         

  1084     TFileName myFile;    

  1085         

  1086     switch( aType )

  1087         {

  1088         case MSTIFTestInterference::ECpuLoad:

  1089             {

  1090             return CPULoad( myActiveTime );

  1091             }

  1092         case MSTIFTestInterference::EFileSystemReadC:

  1093             {           

  1094             RDebug::Print( _L( "STIFTestInterference::EFileSystemReadC" ) );

  1095             

  1096             _LIT( KDrive, "c:\\" );   

  1097             myFile.Format( KDrive );

  1098             

  1099             RFs fileserver;            

  1100             TInt err = fileserver.Connect(); 

  1101             if( err != KErrNone )

  1102                 {

  1103                 RDebug::Print( _L( "RFs connection failed with error: %d" ), err );

  1104                 return err;

  1105                 }          

  1106             CleanupClosePushL( fileserver );                                                                        

  1107 

  1108             err = fileserver.SetSessionPath( myFile );

  1109             if( err != KErrNone )

  1110                 {

  1111                 RDebug::Print( _L( "Drive C is not ready!" ) );                                

  1112                 // R Classes have not created with New, no delete needed

  1113                 CleanupStack::Pop( &fileserver );

  1114                 fileserver.Close();

  1115                 return KErrNone;

  1116                 }                           

  1117                 

  1118             RDebug::Print( _L( "SearchAFileForReading" ) );                  

  1119             err = SearchAFileForReading( myFile, fileserver );                        

  1120             // R Classes have not created with New, no delete needed

  1121             CleanupStack::Pop( &fileserver );

  1122             fileserver.Close();

  1123             if( err != KErrNone )

  1124                 {

  1125                 RDebug::Print( _L( "File not found!" ) );                  

  1126                 return KErrNone;

  1127                 }                            

  1128 

  1129             RDebug::Print( _L( "File's name is: %S" ), &myFile );                     

  1130                         

  1131             return RepeatReadFromFileL( myFile, myActiveTime );

  1132             }

  1133         case MSTIFTestInterference::EFileSystemReadD:

  1134             {

  1135             RDebug::Print( _L( "STIFTestInterference::EFileSystemReadD" ) );