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: CUIEngine: This object executes test cases from 

    15 * STIF Test Framework.

    16 * 

    17 */

    18 

    19 // INCLUDE FILES

    20 #include <e32base.h>

    21 #include <e32svr.h>

    22 #include <collate.h>

    23 #include "UIEngineEvent.h"

    24 #include <stifinternal/UIEngineContainer.h>

    25 #include "UIEngineError.h"

    26 #include <stifinternal/UIEngine.h>

    27 #include "Logging.h"

    28 

    29 // EXTERNAL DATA STRUCTURES

    30 // None

    31 

    32 // EXTERNAL FUNCTION PROTOTYPES

    33 // None

    34 

    35 // CONSTANTS

    36 _LIT( KUIEngine, "CUIEngine" );

    37 

    38 // MACROS

    39 #ifdef LOGGER

    40 #undef LOGGER

    41 #endif

    42 #define LOGGER iLogger

    43 

    44 // LOCAL CONSTANTS AND MACROS

    45 // None

    46 

    47 // MODULE DATA STRUCTURES

    48 // None

    49 

    50 // LOCAL FUNCTION PROTOTYPES

    51 // None

    52 

    53 // FORWARD DECLARATIONS

    54 // None

    55 

    56 // ==================== LOCAL FUNCTIONS ======================================= 

    57 

    58 // ================= MEMBER FUNCTIONS =========================================

    59 

    60 /*

    61 -------------------------------------------------------------------------------

    62 

    63     Class: CUIEngine

    64 

    65     Method: CUIEngine

    66 

    67     Description: Default constructor

    68 

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

    70     might leave.

    71     

    72     Parameters: None

    73     

    74     Return Values: None

    75 

    76     Errors/Exceptions: None

    77 

    78     Status: Draft

    79 

    80 -------------------------------------------------------------------------------

    81 */

    82 CUIEngine::CUIEngine( CUIIf* aUi  ):

    83     iUi( aUi )

    84     {

    85 

    86     __RDEBUG( _L( "CUIEngine::CUIEngine()" ) );

    87     

    88     }

    89 

    90 /*

    91 -------------------------------------------------------------------------------

    92 

    93     Class: CUIEngine

    94 

    95     Method: ConstructL

    96 

    97     Description: Symbian OS second phase constructor

    98 

    99     Symbian OS default constructor can leave.

   100 

   101     Parameters: None

   102 

   103     Return Values: None

   104 

   105     Errors/Exceptions: Leaves if called Open method returns error

   106 

   107     Status: Draft

   108 

   109 -------------------------------------------------------------------------------

   110 */

   111 void CUIEngine::ConstructL()

   112     {

   113     // Logger's setting definitions

   114     TLoggerSettings loggerSettings;

   115     loggerSettings.iCreateLogDirectories = EFalse;

   116     loggerSettings.iOverwrite = ETrue;

   117     loggerSettings.iTimeStamp = ETrue;

   118     loggerSettings.iLineBreak = ETrue;

   119     loggerSettings.iEventRanking = EFalse;

   120     loggerSettings.iThreadId = EFalse;

   121     loggerSettings.iHardwareFormat = CStifLogger::ETxt;

   122     loggerSettings.iHardwareOutput = CStifLogger::EFile;

   123     loggerSettings.iEmulatorFormat = CStifLogger::ETxt;

   124     loggerSettings.iEmulatorOutput = CStifLogger::EFile;

   125     loggerSettings.iUnicode = EFalse;

   126     loggerSettings.iAddTestCaseTitle = EFalse;

   127 

   128     // Create Logger, Note: Use protected NewL because initialization file not

   129     // readed yet.

   130     iLogger = CStifLogger::NewL( KUiLogDir, KUiLogFile, loggerSettings );

   131     

   132     // Initialize logger    

   133     iUi->InitializeLogger( iLogger );

   134 

   135     }

   136 

   137 

   138 /*

   139 -------------------------------------------------------------------------------

   140 

   141     Class: CUIEngine

   142 

   143     Method: NewL

   144 

   145     Description: Two-phased constructor.

   146     

   147     Parameters: None

   148     

   149     Return Values: CUIEngine* : Pointer to created UI engine object

   150 

   151     Errors/Exceptions: Leaves if memory allocation for CUIEngine fails

   152                        Leaves if ConstructL leaves

   153 

   154     Status: Draft

   155 

   156 -------------------------------------------------------------------------------

   157 */

   158 CUIEngine* CUIEngine::NewL( CUIIf* aUi )

   159     {

   160     

   161     CUIEngine* self =  

   162         new ( ELeave ) CUIEngine( aUi );

   163     CleanupStack::PushL( self );

   164     self->ConstructL();

   165     CleanupStack::Pop();

   166     return self;

   167     

   168     }

   169 

   170 

   171 

   172 /*

   173 -------------------------------------------------------------------------------

   174 

   175     Class: CUIEngine

   176 

   177     Method: ~CUIEngine

   178 

   179     Description: Destructor

   180     

   181     Parameters: None

   182 

   183     Return Values: None

   184 

   185     Errors/Exceptions: None

   186 

   187     Status: Draft

   188 

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

   190 */

   191 CUIEngine::~CUIEngine()

   192     {

   193     

   194     __RDEBUG( _L( "CUIEngine::~CUIEngine()" ) );

   195     

   196     // Delete all containers, cannot use ResetAndDestroy,

   197     // because destructor is private

   198     TInt count = iContainerArray.Count();

   199     for( TInt i=0; i< count; i++ )

   200         {

   201         delete iContainerArray[i];

   202         }

   203     iContainerArray.Reset();    

   204     iContainerArray.Close();

   205 

   206     delete iLogger;

   207     iLogger = NULL;

   208     

   209     delete iError;

   210     iError = 0;

   211         

   212     }

   213 

   214 

   215 /*

   216 -------------------------------------------------------------------------------

   217 

   218     Class: VUIEngine

   219 

   220     Method: Open

   221 

   222     Description: Open test engine.

   223 

   224     Parameters: TDesC& aTestFrameworkIni: in: Initialization file to Test Framework

   225 

   226     Return Values: Symbian OS error: Error code

   227 

   228     Errors/Exceptions: None

   229 

   230     Status: Draft

   231 

   232 -------------------------------------------------------------------------------

   233 */

   234 TInt CUIEngine::Open( const TDesC& aTestFrameworkIni )

   235     {

   236     

   237     if( iTestEngine.Handle() != 0 )

   238         {

   239         __TRACE( KError, ( CStifLogger::EError, _L( "CUIEngine::Open() Already open" ) ) );

   240         return KErrInUse;     

   241         }

   242 

   243     // Check aTestFrameworkIni max length

   244     if( aTestFrameworkIni.Length() > KMaxFileName )

   245         {

   246         __TRACE( KPrint, ( CStifLogger::EError, _L( "CUIEngine::Open() method's parameter length is incorrect" ) ) );

   247         return KErrArgument;        

   248         }

   249 

   250     // Create Test Engine

   251     TInt ret = iTestEngine.Connect();

   252 

   253     if ( ret != KErrNone )

   254         {

   255         __TRACE( KPrint, ( _L( "CUIEngine::Open. Engine server open failed: ret = %d"), ret ) );

   256 

   257         return ret;

   258         }

   259 

   260     ret = iTestEngine.LoadConfiguration( aTestFrameworkIni );

   261 

   262     if ( ret != KErrNone )

   263         {

   264         __TRACE( KPrint, ( _L( "CUIEngine::Open. Engine. Open failed: ret = %d"), ret ) );

   265 

   266         return ret;

   267         }

   268 

   269     TErrorNotification error;

   270     if( ErrorPrint( error ) != KErrNotSupported )

   271         {

   272         // Start printer

   273         iError = CUIEngineErrorPrinter::NewL( this );

   274         iError->StartL( iTestEngine );

   275         }

   276 

   277     return ret;

   278     }

   279 

   280 

   281 /*

   282 -------------------------------------------------------------------------------

   283 

   284     Class: CUIEngine

   285 

   286     Method: Close

   287 

   288     Description: Close test engine.

   289 

   290     Parameters: None

   291 

   292     Return Values: TInt KErrNone: Always returned KErrNone

   293 

   294     Errors/Exceptions: None

   295 

   296     Status: Draft

   297 

   298 -------------------------------------------------------------------------------

   299 */

   300 TInt CUIEngine::Close()

   301     {

   302     

   303     delete iError;

   304     iError = 0;

   305     

   306     // Delete all containers, cannot use ResetAndDestroy,

   307     // because destructor is private

   308     TInt count = iContainerArray.Count();

   309     for( TInt i=0; i< count; i++ )

   310         {

   311         delete iContainerArray[i];

   312 		iContainerArray[i] = NULL;

   313         }

   314     iContainerArray.Reset();

   315     

   316     iTestEngine.Close();

   317 

   318     __TRACE( KPrint, ( _L( "CUIEngine::Close." ) ) );

   319 

   320     return KErrNone;

   321     }

   322 

   323 /*

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

   325 

   326     Class: CUIEngine

   327 

   328     Method: AddTestModule

   329 

   330     Description: Add test module to module list of test engine

   331 

   332     Parameters: TDesC& aModuleName: in: Testmodule, which is added to module list

   333                 TDesC& aIniFile: in: Initialization file to the test module

   334 

   335     Return Values: Symbian OS error: Error code

   336 

   337     Errors/Exceptions: None

   338 

   339     Status: Draft

   340 

   341 -------------------------------------------------------------------------------

   342 */

   343 TInt CUIEngine::AddTestModule( const TDesC& aModuleName, 

   344                                const TDesC& aIniFile )

   345     {

   346     // Check aModuleName max length

   347     if( aModuleName.Length() > KMaxName )

   348         {

   349         __TRACE( KPrint, ( CStifLogger::EError, _L( "CUIEngine::AddTestModule() method's first parameter length is incorrect" ) ) );

   350         return KErrArgument;        

   351         }

   352     // Check aIniFile max length

   353     if( aIniFile.Length() > KMaxFileName )

   354         {

   355         __TRACE( KPrint, ( CStifLogger::EError, _L( "CUIEngine::AddTestModule() method's second parameter length is incorrect" ) ) );

   356         return KErrArgument;        

   357         }    

   358 

   359 

   360     TInt ret = iTestEngine.AddTestModule( aModuleName, aIniFile );

   361 

   362     if ( ret != KErrNone && ret != KErrAlreadyExists )

   363         {

   364 		__TRACE( KPrint, ( _L( "CUIEngine::AddTestModule. Add module failed: ret = %d" ), ret  ) );

   365 

   366         return ret;

   367         }

   368 

   369     return KErrNone;

   370     

   371     }

   372 

   373 

   374 /*

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

   376 

   377     Class: CUIEngine

   378 

   379     Method: RemoveTestModule

   380 

   381     Description: Remove test module from test engine

   382 

   383     Parameters: TDesC& aModuleName: in: Testmodule, which is removed of module list

   384 

   385     Return Values: Symbian OS error: Error code

   386 

   387     Errors/Exceptions: None

   388 

   389     Status: Draft

   390 

   391 -------------------------------------------------------------------------------

   392 */

   393 TInt CUIEngine::RemoveTestModule( const TDesC& aModuleName )

   394     {

   395     // Remove test module of module list of test engine

   396     TInt ret = iTestEngine.RemoveTestModule( aModuleName );

   397 

   398     if ( ret != KErrNone )

   399         {

   400         __TRACE( KPrint, ( _L( "CUIEngine::RemoveTestModule. Remove module failed: ret = %d"), ret  ) );

   401 

   402         return ret;

   403         }

   404 

   405     return ret;

   406     }

   407 

   408 

   409 /*

   410 -------------------------------------------------------------------------------

   411 

   412     Class: CUIEngine

   413 

   414     Method: AddTestCaseFile

   415 

   416     Description: Add test case file to test case file list of test engine

   417 

   418     Parameters: TDesC& aModuleName: in: Testmodule, which own test cases of test case list.

   419                 TDesC& aCaseFile: in: Test case list, which is added to test case list

   420 

   421     Return Values: Symbian OS error: Error code

   422 

   423     Errors/Exceptions: None

   424 

   425     Status: Draft

   426 

   427 -------------------------------------------------------------------------------

   428 */

   429 TInt CUIEngine::AddTestCaseFile( const TDesC& aModuleName, 

   430                                  const TDesC& aCaseFile )

   431     {

   432     // Check aModuleName max length

   433     if( aModuleName.Length() > KMaxName )

   434         {

   435         __TRACE( KPrint, ( CStifLogger::EError, _L( "CUIEngine::AddTestCaseFile() method's first parameter length is incorrect" ) ) );

   436         return KErrArgument;        

   437         }

   438     // Check aCaseFile max length

   439     if( aCaseFile.Length() > KMaxFileName )

   440         {

   441         __TRACE( KPrint, ( CStifLogger::EError, _L( "CUIEngine::AddTestCaseFile() method's second parameter length is incorrect" ) ) );

   442         return KErrArgument;        

   443         }

   444     

   445     TInt ret( KErrNone );

   446 

   447     // Add given test case file to test module

   448     if ( aCaseFile.Length() == 0 )

   449         {

   450         ret = KErrArgument;

   451         __TRACE( KPrint, (  _L( "CUIEngine::AddTestCaseFile. Test case file not defined: ret = %d"), ret  ) );

   452         }

   453     else

   454         {

   455         // Add test case file to test case file list of test engine 

   456         ret = iTestEngine.AddConfigFile( aModuleName, aCaseFile );

   457 

   458         if ( ret != KErrNone && ret != KErrAlreadyExists )

   459             {

   460             __TRACE( KPrint, ( _L( "CUIEngine::AddTestCaseFile. Add test case file failed: ret = %d"), ret  ) );

   461             }

   462         }

   463 

   464     return ret;

   465     }

   466 

   467 

   468 /*

   469 -------------------------------------------------------------------------------

   470 

   471     Class: CUIEngine

   472 

   473     Method: RemoveTestCaseFile

   474 

   475     Description: Remove test case file of test case file list of test engine

   476 

   477     Parameters: TDesC& aModuleName: in: Testmodule, which own test cases of test case list

   478                 TDesC& aCaseFile: in: Test case list, which is removed of test case list

   479 

   480     Return Values: Symbian OS error: Error code

   481 

   482     Errors/Exceptions: None

   483 

   484     Status: Draft

   485 

   486 -------------------------------------------------------------------------------

   487 */

   488 TInt CUIEngine::RemoveTestCaseFile( const TDesC& aModuleName, 

   489                                     const TDesC& aCaseFile )

   490     {   

   491     

   492     TInt ret( KErrNone );

   493 

   494     // Remove given test case file from test module

   495     if ( aCaseFile.Length() == 0 )

   496         {

   497         ret = KErrArgument;

   498         __TRACE( KPrint, (  _L( "CUIEngine::RemoveTestCaseFile. Test case file not defined: ret = %d"), ret  ) );

   499         }

   500     else

   501         {

   502         // Remove test case file  

   503         ret = iTestEngine.RemoveConfigFile( aModuleName, aCaseFile );

   504 

   505         if ( ret != KErrNone )

   506             {

   507             __TRACE( KPrint, ( _L( "CUIEngine::RemoveTestCaseFile. Remove test case file failed: ret = %d"), ret  ) );

   508             }

   509         }

   510 

   511     return ret;

   512 

   513     }

   514 

   515 

   516 /*

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

   518 

   519     Class: CUIEngine

   520 

   521     Method: GetTestCases

   522 

   523     Description: Get test cases of enumerated list of test engine. Method is copied 

   524                  list of test cases to aTestCaseInfo. Copied tests are test cases 

   525                  of test module (aTestModule) and defined

   526                  in test case file (aTestCaseFile), which are given as argument

   527 

   528                  Method copied all enumerated test cases if aTestModule

   529                  and aTestCaseFile are not defined

   530     

   531     Parameters: RPointerArray<CTestInfo>& aTestCaseInfo: inout: List of test cases

   532                 TDesC& aModuleName: in: Testmodule, which own test cases of test case list

   533                 TDesC& aTestCaseFile: in: Test case list, which is got of test case list

   534 

   535     Return Values: Symbian OS error: Error code

   536 

   537     Errors/Exceptions: None

   538 

   539     Status: Draft

   540 

   541 -------------------------------------------------------------------------------

   542 */

   543 TInt CUIEngine::GetTestCasesL( RPointerArray<CTestInfo>& aTestCaseInfo,

   544                                const TDesC& aTestModule, 

   545                                const TDesC& aTestCaseFile )

   546     { 

   547 	__TRACE( KPrint, (  _L( "GetTestCasesL()") ) );

   548 

   549     TInt ret(KErrNone);

   550     TInt count(0);

   551 

   552     // Enumerate test cases

   553     TCaseCount caseCount;

   554 

   555     TRequestStatus status;

   556     iTestEngine.EnumerateTestCases( caseCount, status );

   557     User::WaitForRequest( status );

   558     ret = status.Int();

   559 

   560     // Check that enumerate succeeded

   561     if ( ret != KErrNone )

   562         {

   563         __TRACE( KPrint, (  _L( "CUIEngine::GetTestCases. Test case enumerate failed: ret = %d"), ret ) );

   564         TErrorNotification error;

   565         error.iText = _L("Can't get test cases");

   566         iUi->ErrorPrint ( error );  

   567         return ret;

   568         }

   569 

   570     CFixedFlatArray<TTestInfo>* testCases = NULL;

   571 

   572     // Create test cases to buffer

   573     TRAPD( err, testCases = CFixedFlatArray<TTestInfo>::NewL( caseCount() ) );

   574     if( err != KErrNone )

   575         {        

   576         if( err == KErrNoMemory )

   577             {

   578             _LIT( KNotEnoughHeapMemory, 

   579                 "Not enough heap memory available. Either reduce the test case count or increase UI's heap size in mmp file using EPOCHEAPSIZE.");

   580             RDebug::Print( KNotEnoughHeapMemory );

   581         	__TRACE( KError, ( KNotEnoughHeapMemory ) );        

   582         	}

   583         else

   584            {

   585             _LIT( KGeneralError,

   586                 "CUIEngine::GetTestCasesL: CFixedFlatArray<TTestInfo>::NewL fails with value: %d");

   587             RDebug::Print( KGeneralError, err );

   588         	__TRACE( KError, ( KGeneralError, err ) );                   

   589            }        	

   590         User::Leave( err );

   591         }    

   592             

   593     CleanupStack::PushL( testCases );

   594 

   595     // Get test cases from Engine.

   596     ret = iTestEngine.GetTestCases( *testCases );

   597 

   598     if ( ret != KErrNone )

   599         {

   600         __TRACE( KPrint, (  _L( "CUIEngine::GetTestCases. Get test cases failed: ret = %d"), ret ) );

   601 

   602         CleanupStack::PopAndDestroy( testCases );

   603         return ret;

   604         }

   605 

   606     // count of test cases.

   607     count = caseCount();

   608 

   609     __TRACE( KPrint, (  _L( "Test case count: %d"), count ) );

   610     

   611     HBufC* moduleNameBuf = aTestModule.AllocLC();

   612     TPtr moduleName( moduleNameBuf->Des() );

   613     TCollationMethod method = 

   614         *Mem::CollationMethodByIndex(0); // get the standard method

   615     method.iFlags |= TCollationMethod::EFoldCase; // ignore case

   616 

   617     moduleName.LowerCase();

   618 

   619     // Remove optional '.DLL' from test module file name

   620     TParse parse;

   621     parse.Set( moduleName, NULL, NULL );

   622     

   623     if( !parse.Ext().CompareC(  _L(".dll"), 3, &method ) )

   624         {

   625         const TInt len = parse.Ext().Length();

   626         moduleName.Delete ( moduleName.Length()-len, len );

   627         }

   628         

   629     TBool found = EFalse;

   630     // Update iTestCaseTable.

   631     for (TInt j=0;j<count;j++, found = EFalse)

   632         {

   633         // Check, if module defined.

   634         if ( aTestModule.Length() > 0 )

   635             {

   636             // Check, if test case defined.

   637             if ( aTestCaseFile.Length() > 0)

   638                 {

   639                 if( moduleName == KTestScripterName )

   640                     {

   641                     if( !( *testCases )[j].iConfig.CompareC( aTestCaseFile, 3, &method ) )

   642                         {

   643                         found = ETrue;

   644                         }

   645                     }

   646                 if( !( *testCases )[j].iModuleName.CompareC( moduleName, 3, &method )

   647                     && !( *testCases )[j].iConfig.CompareC( aTestCaseFile, 3, &method ) )

   648                     {

   649                     found = ETrue;

   650                     }

   651                 }

   652             else

   653                 {

   654                 if( moduleName == KTestScripterName )

   655                     {

   656                     // Test Module is TestScripter

   657                     if( ( *testCases )[j].iModuleName.Find( KTestScripterName ) != KErrNotFound )

   658                         {

   659                         // iModuleName name is in 'testscripter_testcasefile'

   660                         // format => Find()

   661                         found = ETrue;

   662                         }

   663                     }

   664                 if( !( *testCases )[j].iModuleName.CompareC( 

   665                                             moduleName, 3, &method ) )

   666                     {

   667                     found = ETrue;

   668                     }

   669                 }

   670             }

   671         else

   672             {

   673             found = ETrue;

   674             }

   675         

   676         if( found )

   677             {

   678             // Create tmpTestInfo.

   679             CTestInfo *tmpTestInfo = CTestInfo::NewL();

   680              

   681             CleanupStack::PushL( tmpTestInfo );            

   682 

   683             // Copy TTestInfo to CTestInfo.

   684             tmpTestInfo->SetModuleName( ( *testCases )[j].iModuleName );

   685             tmpTestInfo->SetTestCaseTitle( ( *testCases )[j].iTestCaseInfo.iTitle );

   686             tmpTestInfo->SetTestCaseNumber( ( *testCases )[j].iTestCaseInfo.iCaseNumber );

   687             tmpTestInfo->SetPriority( ( *testCases )[j].iTestCaseInfo.iPriority );

   688             tmpTestInfo->SetTimeout( ( *testCases )[j].iTestCaseInfo.iTimeout );

   689             tmpTestInfo->SetTestCaseFile( ( *testCases )[j].iConfig );

   690             ret = aTestCaseInfo.Append(tmpTestInfo);

   691             if( ret != KErrNone )

   692                 {

   693                 CleanupStack::PopAndDestroy( tmpTestInfo );

   694                 }

   695             else

   696                 {

   697                 CleanupStack::Pop( tmpTestInfo );

   698                 }

   699             }

   700         }

   701     

   702     CleanupStack::PopAndDestroy( moduleNameBuf );

   703 

   704     CleanupStack::PopAndDestroy( testCases );

   705 

   706     return ret;

   707     }

   708 

   709 

   710 /*

   711 -------------------------------------------------------------------------------

   712 

   713     Class: CUIEngine

   714 

   715     Method: StartTestCase

   716 

   717     Description: Start test case execution.

   718 

   719     Parameters: TInt& aTestId: in: ID for test case. Test ID given of address of

   720                 current UIEngineContainer.

   721 

   722                 const CTestInfo& aTestInfo: in: Test case information

   723 

   724     Return Values: Symbian OS error: Error code

   725 

   726     Errors/Exceptions: None

   727 

   728     Status: Draft

   729 

   730 -------------------------------------------------------------------------------

   731 */

   732 TInt CUIEngine::StartTestCase( CUIEngineContainer*& aContainer,

   733                               const CTestInfo& aTestInfo )

   734     {

   735     TInt ret( KErrNone );

   736 

   737     // Copy CTestInfo to TTestInfo.

   738     TTestInfo testCase; 

   739     testCase.iModuleName = aTestInfo.ModuleName();

   740     testCase.iTestCaseInfo.iTitle = aTestInfo.TestCaseTitle();

   741     testCase.iTestCaseInfo.iCaseNumber = aTestInfo.TestCaseNum();

   742     testCase.iTestCaseInfo.iPriority = aTestInfo.Priority();

   743     testCase.iTestCaseInfo.iTimeout = aTestInfo.Timeout();

   744     testCase.iConfig = aTestInfo.TestCaseFile();

   745 

   746     CUIEngineContainer* container = NULL;

   747     TRAP( ret,

   748         // Create container.

   749         container = 

   750             CUIEngineContainer::NewL( this, testCase, iTestEngine );

   751     );

   752     if( ret != KErrNone )

   753         {

   754         return ret;

   755         }

   756     

   757     ret = iContainerArray.Append( container );

   758     if( ret != KErrNone )

   759         {

   760         __TRACE( KError, ( CStifLogger::EError, 

   761             _L( "CUIEngine::StartTestCase() Append failed, cannot start test case" ) ) );

   762         delete container;

   763         return ret;

   764         }

   765         

   766     // Call Container to starting test case execution.

   767     TRAPD( trapError,

   768     // Call Container to starting test case execution.

   769     ret = container->StartContainerL();

   770     );

   771 

   772     if(trapError != KErrNone)

   773         {

   774         __TRACE( KPrint, (  _L( "CUIEngine::StartTestCase. Test case starting failed: trapError = %d"), ret ) );

   775         delete container;

   776         return trapError;

   777         }

   778         

   779     aContainer = container;

   780 

   781     return ret;

   782     

   783     }

   784     

   785 /*

   786 -------------------------------------------------------------------------------

   787 

   788     Class: CUIEngine

   789 

   790     Method: AbortStartedTestCase

   791 

   792     Description: Abort started test case execution.

   793 

   794     Parameters: CUIEngineContainer* aContainer: in: Container running testcase

   795 

   796     Return Values: Symbian OS error: Error code

   797 

   798     Errors/Exceptions: Panics if test case is not found or is already executed

   799 

   800     Status: Draft

   801 

   802 -------------------------------------------------------------------------------

   803 */

   804 void CUIEngine::AbortStartedTestCase( CUIEngineContainer* aContainer )

   805     {

   806     

   807     // Locate container from array

   808     TInt index = iContainerArray.Find( aContainer );

   809     

   810     if( ( index < 0) ||

   811         ( aContainer->State() == CUIEngineContainer::EExecuted ) )

   812         {

   813         __TRACE( KError, ( CStifLogger::EError, 

   814             _L( "CUIEngine::AbortStartedTestCase() Testcase executed" ) ) );

   815         User::Panic( KUIEngine, KErrAccessDenied );

   816         }

   817         

   818     // Remove and delete container

   819     iContainerArray.Remove( index );

   820     delete aContainer;

   821     

   822     }

   823 

   824     

   825 /*

   826 -------------------------------------------------------------------------------

   827 

   828     Class: CUIEngine

   829 

   830     Method: TestExecuted

   831 

   832     Description: 

   833 

   834     Parameters: CUIEngineContainer* aUIEngineContainer: Address of current

   835                 CUIEngineContainer is test case ID.

   836 

   837                 TFullTestResult& aFullTestResult: in: Test result of executed test case

   838 

   839     Return Values: TInt KErrNone: Always returned KErrNone

   840 

   841     Errors/Exceptions: None

   842 

   843     Status: Draft

   844 

   845 -------------------------------------------------------------------------------

   846 */

   847 void CUIEngine::TestExecuted( CUIEngineContainer* aContainer, 

   848                                TFullTestResult& aFullTestResult )

   849     {

   850      // Locate container from array

   851     TInt index = iContainerArray.Find( aContainer );

   852     

   853     if( index < 0 )

   854         {

   855         __TRACE( KError, ( CStifLogger::EError, 

   856             _L( "CUIEngine::TestExecuted() Testcase not found" ) ) );

   857         User::Panic( KUIEngine, KErrNotFound );

   858         }

   859     

   860     iUi->TestExecuted( aContainer, aFullTestResult );

   861     

   862     // Remove and delete container.

   863     // It is safe to do here,

   864     // because container and runner does not have any code after

   865     // this function returns.

   866     iContainerArray.Remove( index );

   867     delete aContainer;

   868    

   869     }

   870 

   871 

   872 /*

   873 -------------------------------------------------------------------------------

   874 

   875     Class: CUIEngine

   876 

   877     Method: PrintProg

   878 

   879     Description: 

   880 

   881     Parameters: CUIEngineContainer* aContainer: in: Address of current

   882                 CUIEngineContainer is test case ID

   883 

   884                 TTestProgress& aProgress: in: Progress information from test case

   885 

   886     Return Values: SymbianOS error code

   887 

   888     Errors/Exceptions: None

   889 

   890     Status: Draft

   891 

   892 -------------------------------------------------------------------------------

   893 */

   894 TInt CUIEngine::PrintProg( CUIEngineContainer* aContainer, 

   895                           TTestProgress& aProgress )

   896     {

   897 

   898     return iUi->PrintProg( aContainer, aProgress );

   899         

   900     }

   901 

   902 /*

   903 -------------------------------------------------------------------------------

   904 

   905     Class: CUIEngine

   906 

   907     Method: ErrorPrint

   908 

   909     Description: 

   910 

   911     Parameters: TErrorNotification& aError: in: Error information from framework

   912 

   913     Return Values: SymbianOS error code

   914 

   915     Errors/Exceptions: None

   916 

   917     Status: Draft

   918 

   919 -------------------------------------------------------------------------------

   920 */

   921 TInt CUIEngine::ErrorPrint( TErrorNotification& aError )

   922     {

   923 

   924     return iUi->ErrorPrint( aError );

   925         

   926     }

   927    

   928 /*

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

   930 

   931     Class: CUIEngine

   932 

   933     Method: RemoteMsg

   934 

   935     Description: Forward Ats send.

   936 

   937     Parameters: const TDesC& aMessage: in: message

   938     

   939     Return Values: SymbianOS error code

   940 

   941     Errors/Exceptions: None

   942 

   943     Status: Draft

   944 

   945 -------------------------------------------------------------------------------

   946 */

   947 TInt CUIEngine::RemoteMsg( CUIEngineContainer* aContainer, 

   948                            const TDesC& aMessage )

   949     {

   950 

   951     return iUi->RemoteMsg( aContainer, aMessage );

   952         

   953     }

   954 

   955 /*

   956 -------------------------------------------------------------------------------

   957 

   958     Class: CUIEngine

   959 

   960     Method: GoingToReboot

   961 

   962     Description: Forward reboot indication.

   963 

   964     Parameters: None

   965     

   966     Return Values: SymbianOS error code

   967 

   968     Errors/Exceptions: None

   969 

   970     Status: Draft

   971 

   972 -------------------------------------------------------------------------------

   973 */

   974 TInt CUIEngine::GoingToReboot( CUIEngineContainer* aContainer,

   975                                TRequestStatus& aStatus )

   976     {

   977 

   978     return iUi->GoingToReboot( aContainer, aStatus );

   979         

   980     }

   981 

   982 

   983 /*

   984 -------------------------------------------------------------------------------

   985 

   986     DESCRIPTION

   987 

   988     CTestInfo: This object contains test case information.

   989 

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

   991 */

   992 

   993 // ================= MEMBER FUNCTIONS =========================================

   994 

   995 

   996 /*

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

   998 

   999     Class: CTestInfo

  1000 

  1001     Method: NewL

  1002 

  1003     Description:

  1004 

  1005     Parameters: None

  1006 

  1007     Return Values: None

  1008 

  1009     Errors/Exceptions: None

  1010 

  1011     Status: Draft

  1012 

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

  1014 */

  1015 EXPORT_C CTestInfo* CTestInfo::NewL()

  1016     {

  1017     

  1018     //RDebug::Print(_L("CTestInfo::NewL()"));

  1019     CTestInfo* self =  

  1020         new ( ELeave ) CTestInfo();

  1021     CleanupStack::PushL( self );

  1022     self->ConstructL();

  1023     CleanupStack::Pop();

  1024     return self;

  1025     

  1026     }

  1027 

  1028 /*

  1029 -------------------------------------------------------------------------------

  1030 

  1031     Class: CTestInfo

  1032 

  1033     Method: CTestInfo

  1034 

  1035     Description: Default constructor

  1036 

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

  1038     might leave.

  1039     

  1040     Parameters: None

  1041     

  1042     Return Values: None

  1043 

  1044     Errors/Exceptions: None

  1045 

  1046     Status: Draft

  1047 

  1048 -------------------------------------------------------------------------------

  1049 */

  1050 CTestInfo::CTestInfo()

  1051     {

  1052     }

  1053 

  1054 /*

  1055 -------------------------------------------------------------------------------

  1056 

  1057     Class: CTestInfo

  1058 

  1059     Method: ConstructL

  1060 

  1061     Description: Symbian OS second phase constructor

  1062 

  1063     Symbian OS default constructor can leave.

  1064 

  1065     Parameters: None

  1066 

  1067     Return Values: None

  1068 

  1069     Errors/Exceptions: Leaves if called Open method returns error

  1070 

  1071     Status: Draft

  1072 

  1073 -------------------------------------------------------------------------------

  1074 */

  1075 void CTestInfo::ConstructL()

  1076     {   

  1077     }

  1078     

  1079 /*

  1080 -------------------------------------------------------------------------------

  1081 

  1082     Class: CTestInfo

  1083 

  1084     Method: ~CTestInfo

  1085 

  1086     Description: Destructor

  1087     

  1088     Parameters: None

  1089 

  1090     Return Values: None

  1091 

  1092     Errors/Exceptions: None

  1093 

  1094     Status: Draft

  1095 

  1096 -------------------------------------------------------------------------------

  1097 */

  1098 CTestInfo::~CTestInfo()

  1099     {

  1100     

  1101     delete iModuleNameBuf;

  1102     delete iTitleBuf;

  1103     delete iTestCaseFileBuf;

  1104     iModuleNameBuf = 0;

  1105     iTitleBuf = 0;

  1106     iTestCaseFileBuf = 0;

  1107     

  1108     }

  1109 

  1110 /*

  1111 -------------------------------------------------------------------------------

  1112 

  1113     Class: CTestInfo

  1114 

  1115     Method: SetModuleName

  1116 

  1117     Description: Set module name.

  1118     

  1119     Parameters: None

  1120 

  1121     Return Values: Symbian OS error code

  1122 

  1123     Errors/Exceptions: None

  1124 

  1125     Status: Draft

  1126 

  1127 -------------------------------------------------------------------------------

  1128 */

  1129 TInt CTestInfo::SetModuleName ( const TDesC& aModuleName ) 

  1130     {

  1131     

  1132     iModuleName.Set(0,0); 

  1133     delete iModuleNameBuf;

  1134 

  1135     if( aModuleName.Length() < KTestScripterNameLength )