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 implementation of CUIStore 

    15 * and CModule class member functions.

    16 *

    17 */

    18 

    19 // INCLUDE FILES

    20 #include <e32base.h>

    21 #include <e32svr.h>

    22 #include <f32file.h>

    23 #include <e32uid.h>

    24 #include <collate.h>

    25 

    26 #include <StifLogger.h>

    27 

    28 #include "Logging.h"

    29 #include <stifinternal/UIStore.h>

    30 #include <stifinternal/UIEngine.h>

    31 #include <stifinternal/UIStoreContainer.h>

    32 #include "UIStorePopup.h"

    33 #include <stifinternal/UIEngineContainer.h>

    34 

    35 

    36 // EXTERNAL DATA STRUCTURES

    37 

    38 // EXTERNAL FUNCTION PROTOTYPES  

    39 

    40 // CONSTANTS

    41 //@spe _LIT(KNameTxt,"TEST FRAMEWORK");

    42 //@spe _LIT(KNameBase,"BASE");

    43 _LIT( KUIStore, "CUiStore" );

    44 _LIT( KUIStoreIf, "CUiStoreIf" );

    45 //_LIT( KUIStoreDefaultDir, "C:\\TestFramework\\" );

    46 

    47 _LIT( KUIStoreSetStart, "[TestSetStart]" );

    48 _LIT( KUIStoreSetEnd, "[TestSetEnd]" );

    49 _LIT( KUIStoreSetCaseStart, "[TestSetCaseStart]" );

    50 _LIT( KUIStoreSetCaseEnd, "[TestSetCaseEnd]" );

    51 _LIT( KUIStoreCaseModuleName, "ModuleName=" );

    52 _LIT( KUIStoreTestCaseTitle, "Title=" );

    53 _LIT( KUIStoreTestCaseFile, "TestCaseFile="); 

    54 _LIT( KUIStoreTestCaseNum, "TestCaseNum=");

    55 _LIT( KUIStoreCaseExpectedResult, "ExpectedResult=");

    56 _LIT( KUIStoreCasePriority, "Priority="); 

    57 _LIT( KUIStoreCaseTimeout, "Timeout=");

    58 _LIT( KUIStoreLastStartedCaseIndex, "LastStartedCaseIndex=");

    59 

    60 

    61 _LIT( KUIStoreDefaultRebootFile, "TestFrameworkUIReboot.txt" );

    62 _LIT( KUIStoreStartTest, "[StartTestCase]" );

    63 _LIT( KUIStoreStartTestEnd, "[StartTestCaseEnd]" );

    64 

    65 _LIT( KUIStoreCaseStatus, "TestCaseStatus=");

    66 _LIT( KUIStoreCaseExecutionResult, "TestCaseExecutionResult=");

    67 _LIT( KUIStoreCaseResult, "TestCaseResult=");

    68 _LIT( KUIStoreCaseStartTime, "TestCaseStartTime=");

    69 _LIT( KUIStoreCaseEndTime, "TestCaseEndTime=");

    70 

    71 const TInt KRcpHeaderLen = 16;        

    72 const TInt KFixedStartedCaseIndex = 10;

    73 

    74 // MACROS

    75 #ifdef LOGGER

    76 #undef LOGGER

    77 #endif

    78 #define LOGGER iLogger

    79 

    80 // LOCAL CONSTANTS AND MACROS

    81 static const TUid KUidTestModule = { 0x101FB3E7 };

    82 

    83 // MODULE DATA STRUCTURES

    84 

    85 // LOCAL FUNCTION PROTOTYPES

    86 

    87 // FORWARD DECLARATIONS

    88 

    89 

    90 // ==================== LOCAL FUNCTIONS =======================================

    91 

    92 // None

    93 

    94 // ================= MEMBER FUNCTIONS =========================================

    95 

    96 /*

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

    98 

    99     Class: CUIStore

   100 

   101     Method: NewL

   102 

   103     Description: Construct the CUIStore class

   104 

   105     Parameters: None

   106 

   107     Return Values: CUIStore*                    New object

   108 

   109     Errors/Exceptions: Leaves if memory allocation fails or

   110                        ConstructL leaves.

   111 

   112     Status: Draft

   113 

   114 -------------------------------------------------------------------------------

   115 */

   116 CUIStore* CUIStore::NewL( CUIStoreIf* aUIStoreIf )

   117     {

   118     

   119     CUIStore* self = new ( ELeave ) CUIStore( aUIStoreIf );

   120     CleanupStack::PushL( self );

   121     self->ConstructL();

   122     CleanupStack::Pop( self );

   123 

   124     return self;

   125 

   126     }

   127 

   128 

   129 /*

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

   131 

   132     Class: CUIStore

   133 

   134     Method: ConstructL

   135 

   136     Description: Second level constructor.

   137 

   138     Construct the console

   139     Construct module and case containers

   140     Retrieve command line parameters

   141     Connect to test engine

   142 

   143     Parameters: None

   144 

   145     Return Values: None

   146 

   147     Errors/Exceptions: Leaves if memory allocation fails or fileserver or

   148                        test engine can't be connected.

   149 

   150     Status: Draft

   151 

   152 -------------------------------------------------------------------------------

   153 */

   154 void CUIStore::ConstructL( )

   155     {

   156     }

   157 

   158 

   159 /*

   160 -------------------------------------------------------------------------------

   161 

   162     Class: CUIStore

   163 

   164     Method: CUIStore

   165 

   166     Description: Constructor.

   167     Initialize non-zero member variables.

   168 

   169     Parameters: None

   170 

   171     Return Values: None

   172 

   173     Errors/Exceptions: None

   174 

   175     Status: Draft

   176 

   177 -------------------------------------------------------------------------------

   178 */

   179 CUIStore::CUIStore( CUIStoreIf* aUIStoreIf ):

   180     iUIStoreIf( aUIStoreIf ),

   181     iUpdateNeeded( ETrue ),

   182     iActivePopupPriority( EPopupPriorityLow )

   183     {

   184     }

   185 

   186 /*

   187 -------------------------------------------------------------------------------

   188 

   189     Class: CUIStore

   190 

   191     Method: ~CUIStore

   192 

   193     Description: Destructor

   194 

   195     Parameters: None

   196 

   197     Return Values: None

   198 

   199     Errors/Exceptions: None

   200 

   201     Status: Draft

   202 

   203 -------------------------------------------------------------------------------

   204 */

   205 CUIStore::~CUIStore( )

   206     {	

   207 

   208     iFileList.ResetAndDestroy();

   209     iFileList.Close(); 

   210     iStartedTestSets.ResetAndDestroy();

   211     iStartedTestSets.Close();  

   212 

   213     iStartedTestCases.ResetAndDestroy();

   214     iStartedTestCases.Close();

   215     

   216     iTestSets.ResetAndDestroy();

   217     iTestSets.Close();  

   218 

   219     iTestCases.ResetAndDestroy();

   220     iTestCases.Close();

   221     

   222     iPopups.ResetAndDestroy();

   223     iPopups.Close();

   224         

   225     delete iUIEngine;    

   226     iUIEngine = 0;

   227 

   228     }

   229 /*

   230 -------------------------------------------------------------------------------

   231 

   232     Class: CStifTFwIf

   233 

   234     Method: Open

   235 

   236     Description: Open test engine.

   237 

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

   239 

   240     Return Values: Symbian OS error: Error code

   241 

   242     Errors/Exceptions: None

   243 

   244     Status: Draft

   245 

   246 -------------------------------------------------------------------------------

   247 */

   248 EXPORT_C  TInt CUIStore::Open( const TDesC& aTestFrameworkIni )

   249     {

   250     

   251     if( aTestFrameworkIni.Length() > KMaxFileName )

   252         {

   253         return KErrArgument;

   254         }

   255     

   256     TRAPD( err, 

   257         iUIEngine = CUIEngine::NewL( this );

   258         );

   259     if( err != KErrNone )

   260         {

   261         return err;

   262         }

   263     

   264     TFileName ini( aTestFrameworkIni );

   265     // Check given ini file

   266     TRAP( err, CheckIniL( ini ) );

   267     

   268     // Store folder of initialization file to open it again when looking for filters

   269     RDebug::Print(_L("CUIStore stores name of ini file [%S]"), &ini);

   270     iTestFrameworkIni.Copy(ini);

   271     

   272     return iUIEngine->Open( ini );

   273     

   274     }

   275 

   276 

   277 /*

   278 -------------------------------------------------------------------------------

   279 

   280     Class: CUIStore

   281 

   282     Method: Close

   283 

   284     Description: Close test engine.

   285 

   286     Parameters: None

   287 

   288     Return Values: TInt KErrNone: Always returned KErrNone

   289 

   290     Errors/Exceptions: None

   291 

   292     Status: Draft

   293 

   294 -------------------------------------------------------------------------------

   295 */

   296 EXPORT_C TInt CUIStore::Close()

   297     {

   298     

   299     TInt ret = KErrNone;

   300     if( iUIEngine != NULL )

   301         {

   302         ret = iUIEngine->Close();

   303     

   304         delete iUIEngine;    

   305         iUIEngine = 0;

   306         }

   307         

   308     return ret;

   309 

   310     }

   311 

   312 /*

   313 -------------------------------------------------------------------------------

   314 

   315     Class: CUIStore

   316 

   317     Method: AddTestModule

   318 

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

   320 

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

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

   323 

   324     Return Values: Symbian OS error: Error code

   325 

   326     Errors/Exceptions: None

   327 

   328     Status: Draft

   329 

   330 -------------------------------------------------------------------------------

   331 */

   332 EXPORT_C TInt CUIStore::AddTestModule( const TDesC& aModuleName, 

   333                                        const TDesC& aIniFile )

   334     {

   335 

   336     TInt ret = iUIEngine->AddTestModule( aModuleName, aIniFile );

   337          

   338     RefreshAllCases();

   339     

   340     return ret;

   341          

   342     }

   343 

   344 

   345 /*

   346 -------------------------------------------------------------------------------

   347 

   348     Class: CUIStore

   349 

   350     Method: RemoveTestModule

   351 

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

   353 

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

   355 

   356     Return Values: Symbian OS error: Error code

   357 

   358     Errors/Exceptions: None

   359 

   360     Status: Draft

   361 

   362 -------------------------------------------------------------------------------

   363 */

   364 EXPORT_C TInt CUIStore::RemoveTestModule( const TDesC& aModuleName )

   365     {

   366 

   367     TInt ret = iUIEngine->RemoveTestModule( aModuleName );

   368      

   369     RefreshAllCases();

   370     

   371     return ret;

   372     

   373     }

   374 

   375 

   376 /*

   377 -------------------------------------------------------------------------------

   378 

   379     Class: CUIStore

   380 

   381     Method: AddTestCaseFile

   382 

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

   384 

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

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

   387 

   388     Return Values: Symbian OS error: Error code

   389 

   390     Errors/Exceptions: None

   391 

   392     Status: Draft

   393 

   394 -------------------------------------------------------------------------------

   395 */

   396 EXPORT_C TInt CUIStore::AddTestCaseFile( const TDesC& aModuleName, 

   397                                          const TDesC& aCaseFile )

   398     {

   399 

   400     TInt ret = iUIEngine->AddTestCaseFile( aModuleName, aCaseFile );

   401      

   402     RefreshAllCases();

   403     

   404     return ret;

   405     

   406     }

   407 

   408 

   409 /*

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

   411 

   412     Class: CUIStore

   413 

   414     Method: RemoveTestCaseFile

   415 

   416     Description: Remove test case file of 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 removed of 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 EXPORT_C TInt CUIStore::RemoveTestCaseFile( const TDesC& aModuleName, 

   430                                             const TDesC& aCaseFile )

   431     {   

   432     

   433     TInt ret = iUIEngine->RemoveTestCaseFile( aModuleName, aCaseFile );

   434          

   435     RefreshAllCases();

   436     

   437     return ret;

   438     

   439     }

   440     

   441 /*

   442 -------------------------------------------------------------------------------

   443 

   444     Class: CUIStore

   445 

   446     Method: StartTestCase

   447 

   448     Description: Start selected test case identified with CTestInfo.

   449                 anIndex contains index in StartedTestCase array, 

   450                 which is valid only during execution of calling 

   451                 function.

   452 

   453     Parameters: const CTestInfo& aTestInfo: in: Test case info

   454                 TInt& anIndex: out: Index to StartedTestCaseArray returned 

   455 

   456     Return Values: Symbian OS error code

   457 

   458     Errors/Exceptions: None

   459 

   460     Status: Draft

   461 

   462 -------------------------------------------------------------------------------

   463 */

   464 EXPORT_C TInt CUIStore::StartTestCase( const CTestInfo& aTestInfo, 

   465                                        TInt& anIndex )

   466     {

   467     

   468     CUIEngineContainer* container = NULL;

   469     TInt ret = iUIEngine->StartTestCase( container, aTestInfo );

   470     

   471     if( ret != KErrNone )

   472         {

   473         return ret;

   474         }

   475     

   476     CStartedTestCase* testCase = NULL;

   477     TRAP( ret,

   478         testCase = CStartedTestCase::NewL( aTestInfo, *container );

   479        );

   480     if( ret != KErrNone )

   481         {

   482         iUIEngine->AbortStartedTestCase( container );

   483         return ret;

   484         }

   485         

   486     ret = iStartedTestCases.Append( testCase );

   487     if( ret != KErrNone )

   488         {

   489         iUIEngine->AbortStartedTestCase( container );

   490         delete testCase;

   491         return ret;

   492         }

   493     

   494     anIndex =  iStartedTestCases.Find( testCase );

   495     

   496     if( anIndex < 0 )

   497         {

   498         User::Panic( KUIStore, KErrNotFound );

   499         }

   500     

   501     iUIStoreIf->Update( testCase, testCase->Status() ); 

   502                 

   503     return KErrNone;

   504     

   505     }

   506     

   507 /*

   508 -------------------------------------------------------------------------------

   509 

   510     Class: CUIStore

   511 

   512     Method: TestCases

   513 

   514     Description: Return array of existing test cases.

   515 

   516     Parameters: RRefArray<CTestInfo>& aTestCases: out: Array of test cases

   517                 TDesC& aTestModule: in: Test module name (optional)

   518                 TDesC& aTestCaseFile: in: Test case file name (optional) 

   519 

   520     Return Values: Symbian OS error code

   521 

   522     Errors/Exceptions: None

   523 

   524     Status: Draft

   525 

   526 -------------------------------------------------------------------------------

   527 */

   528 EXPORT_C TInt CUIStore::TestCases( RRefArray<CTestInfo>& aTestCases, 

   529                                    const TDesC& aTestModule,

   530                                    const TDesC& aTestCaseFile ) 

   531     {

   532     

   533     TInt ret = UpdateCases();

   534     if( ret != KErrNone )

   535         {

   536         return ret;

   537         }

   538     TInt count = iTestCases.Count();

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

   540         {

   541         if( ( aTestModule.Length() > 0 ) &&

   542             ( iTestCases[i]->ModuleName() != aTestModule ) )

   543             {

   544             continue;

   545             }

   546         else if( ( aTestCaseFile.Length() > 0 ) &&

   547                  ( iTestCases[i]->TestCaseFile() != aTestCaseFile ) )

   548             {

   549             continue;

   550             }

   551         aTestCases.Append( *iTestCases[i] );

   552         }

   553     

   554     return KErrNone;

   555     

   556     }

   557 

   558 /*

   559 -------------------------------------------------------------------------------

   560 

   561     Class: CUIStore

   562 

   563     Method: StartedTestCaseL

   564 

   565     Description: Return started (running/runned) test case

   566 

   567     Parameters: CStartedTestCase& aTestCase: out: Test case information

   568                 TInt anIndex: in: test case index in StartedTestCaseArray

   569 

   570     Return Values: Reference to CStartedTestCase object

   571 

   572     Errors/Exceptions: Leaves if anIndex out of range

   573 

   574     Status: Draft

   575 

   576 -------------------------------------------------------------------------------

   577 */      

   578 EXPORT_C CStartedTestCase& CUIStore::StartedTestCaseL( TInt anIndex )

   579     {

   580     

   581     TInt count = iStartedTestCases.Count();

   582     if( ( anIndex >= count ) ||

   583         ( anIndex < 0 ) )

   584         {

   585         User::Leave( KErrNotFound );

   586         }

   587         

   588     return *iStartedTestCases[anIndex];

   589          

   590     }

   591 

   592 /*

   593 -------------------------------------------------------------------------------

   594 

   595     Class: CUIStore

   596 

   597     Method: StartedTestCases

   598 

   599     Description: Return started (running/runned) test cases

   600 

   601     Parameters: RRefArray<CStartedTestCase>& aTestCases: out: array of test cases

   602                 TExecutionStatus aStatus: in: test case status (optional)

   603                 TDesC& aTestModule: in: test module name (optional)

   604                 TDesC& aTestCaseFile: in: test case file name (optional)

   605 

   606     Return Values: Symbian OS error code

   607 

   608     Errors/Exceptions: None

   609 

   610     Status: Draft

   611 

   612 -------------------------------------------------------------------------------

   613 */            

   614 EXPORT_C TInt CUIStore::StartedTestCases( RRefArray<CStartedTestCase>& aTestCases,

   615                                           TInt aStatus,

   616                                           const TDesC& aTestModule,

   617                                           const TDesC& aTestCaseFile )

   618     {

   619     

   620     TInt count = iStartedTestCases.Count();

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

   622         {

   623         if( ( aTestModule.Length() > 0 ) &&

   624             ( iStartedTestCases[i]->TestInfo().ModuleName() != aTestModule ) )

   625             {

   626             continue;

   627             }

   628         else if( ( aTestCaseFile.Length() > 0 ) &&

   629                  ( iStartedTestCases[i]->TestInfo().TestCaseFile() != aTestCaseFile ) )

   630             {

   631             continue;

   632             }

   633         else if( ( aStatus != CUIStoreIf::EStatusAll) &&

   634                  !( iStartedTestCases[i]->Status() & aStatus ) )

   635             {

   636             continue;

   637             }

   638         if( aTestCases.Append( *iStartedTestCases[i] ) != KErrNone )

   639             {

   640             return KErrNoMemory;

   641             }

   642         }

   643     

   644     

   645     return KErrNone;

   646     

   647     }

   648             

   649 /*

   650 -------------------------------------------------------------------------------

   651 

   652     Class: CUIStore

   653 

   654     Method: Modules

   655 

   656     Description: Return modules array

   657 

   658     Parameters: RRefArray<CModule>& aTestModules: out: modules array

   659 

   660     Return Values: Symbian OS error code

   661 

   662     Errors/Exceptions: None

   663 

   664     Status: Draft

   665 

   666 -------------------------------------------------------------------------------

   667 */     

   668 EXPORT_C TInt CUIStore::Modules( RRefArray<TDesC>& aTestModules )

   669     {

   670 

   671     TInt ret = UpdateCases();

   672     if( ret != KErrNone )

   673         {

   674         return ret;

   675         }

   676 

   677     // Go through test cases and search if there are new modules 

   678     // and add them to aTestModules array 

   679     TInt caseCount = iTestCases.Count();

   680     TInt moduleCount = 0;

   681     TInt caseIndex = 0;

   682     TInt moduleIndex = 0;

   683     for ( caseIndex = 0; caseIndex < caseCount; caseIndex++ )

   684         {

   685         // First check modules

   686         moduleCount = aTestModules.Count();

   687         for ( moduleIndex = 0; moduleIndex < moduleCount; moduleIndex++ )

   688             {

   689             if( iTestCases[caseIndex]->ModuleName() == 

   690                 aTestModules[moduleIndex] )

   691                 {

   692                 break;

   693                 }

   694             }

   695         if ( moduleIndex == moduleCount )

   696             {

   697             // New module found

   698             if( aTestModules.Append( iTestCases[caseIndex]->ModuleName() ) !=

   699                 KErrNone )

   700                 {

   701                 return KErrNoMemory;

   702                 } 

   703             }

   704         }

   705 

   706     return KErrNone;

   707 

   708     }

   709 

   710 /*

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

   712 

   713     Class: CUIStore

   714 

   715     Method: TestCaseFiles

   716 

   717     Description: Return test case files

   718 

   719     Parameters: RRefArray<TDesC>& aTestCaseFiles: out: Array of test case files

   720                 TDesC& aTestModule: in: test module name (optional)

   721 

   722     Return Values: Symbian OS error code

   723 

   724     Errors/Exceptions: None

   725 

   726     Status: Draft

   727 

   728 -------------------------------------------------------------------------------

   729 */     

   730 EXPORT_C TInt CUIStore::TestCaseFiles( RRefArray<TDesC>& aTestCaseFiles,

   731                                        const TDesC& aTestModule  )

   732     {

   733     

   734     TInt ret = UpdateCases();

   735     if( ret != KErrNone )

   736         {

   737         return ret;

   738         }

   739 

   740     // Go through test cases and search if there are new test case files 

   741     // for specified test module and add them to aTestCaseFiles array 

   742     TInt caseCount = iTestCases.Count();

   743     TInt fileCount = 0;

   744     TInt caseIndex = 0;

   745     TInt fileIndex = 0;

   746     for ( caseIndex = 0; caseIndex < caseCount; caseIndex++ )

   747         {

   748         if( ( aTestModule.Length() > 0 ) &&

   749             ( aTestModule != iTestCases[caseIndex]->ModuleName() ) )

   750             {

   751             // Test case file is not for specified module

   752             continue;

   753             }

   754             

   755         // First check modules

   756         fileCount = aTestCaseFiles.Count();

   757         for ( fileIndex = 0; fileIndex < fileCount; fileIndex++ )

   758             {

   759             if( iTestCases[caseIndex]->TestCaseFile() == 

   760                 aTestCaseFiles[fileIndex] )

   761                 {

   762                 break;

   763                 }

   764             }

   765         if ( fileIndex == fileCount )

   766             {

   767             // New test case file found

   768             if( aTestCaseFiles.Append( iTestCases[caseIndex]->TestCaseFile() ) !=

   769                 KErrNone )

   770                 {

   771                 return KErrNoMemory;

   772                 } 

   773             }

   774         }

   775 

   776     return KErrNone;

   777     

   778     }

   779 

   780 /*

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

   782 

   783     Class: CUIStore

   784 

   785     Method: LoadAllModules

   786 

   787     Description: Loads all TestFramework test modules from \system\libs\ directories 

   788                 of all drives. In Secure Platform from \sys\bin directories.

   789 

   790     Parameters: None

   791     

   792     Return Values: Symbian OS error code

   793 

   794     Errors/Exceptions: None

   795 

   796     Status: Draft

   797 

   798 -------------------------------------------------------------------------------

   799 */ 

   800 EXPORT_C TInt CUIStore::LoadAllModules()

   801     {

   802     

   803     RPointerArray<TDesC> testModules;

   804     

   805     TInt ret = ListAllModules( testModules );

   806     if( ret == KErrNone )

   807         {

   808         for (TInt i= 0; i < testModules.Count(); i++)

   809             {

   810             iLogger->Log( _L("Add test module: %S"), testModules[i] );

   811             ret = iUIEngine->AddTestModule( *testModules[i], KNullDesC );

   812             if( ret != KErrNone )

   813                 {

   814                 iLogger->Log( _L("Add test module %S failed %d"), 

   815                     testModules[i], ret );

   816                 break;

   817                 }

   818             }

   819         }

   820     RefreshAllCases();

   821     

   822     testModules.ResetAndDestroy();

   823     testModules.Close();

   824     

   825     return ret;

   826 

   827     }    

   828 

   829 /*

   830 -------------------------------------------------------------------------------

   831 

   832     Class: CUIStore

   833 

   834     Method: ListAllModules

   835 

   836     Description: Lists all TestFramework test modules from \system\libs\ directories 

   837                 of all drives. In Secure Platform from \sys\bin directories.

   838 

   839     Parameters: None

   840     

   841     Return Values: Symbian OS error code

   842 

   843     Errors/Exceptions: None

   844 

   845     Status: Draft

   846 

   847 -------------------------------------------------------------------------------

   848 */ 

   849 EXPORT_C TInt CUIStore::ListAllModules( RPointerArray<TDesC>& aModuleNames )

   850     {

   851     

   852     TRAPD( err, ListAllModulesL( aModuleNames ); );

   853     return err;

   854     

   855     }

   856     

   857 /*

   858 -------------------------------------------------------------------------------

   859 

   860     Class: CUIStore

   861 

   862     Method: ListAllModulesL

   863 

   864     Description: Lists all TestFramework test modules from \system\libs\ directories 

   865                 of all drives. In Secure Platform from \sys\bin directories.

   866 

   867     Parameters: None

   868     

   869     Return Values: Symbian OS error code

   870 

   871     Errors/Exceptions: None

   872 

   873     Status: Draft

   874 

   875 -------------------------------------------------------------------------------

   876 */ 

   877 void CUIStore::ListAllModulesL( RPointerArray<TDesC>& aModuleNames )

   878     {

   879 

   880     TFileName libDirectory;

   881     RFs fsSession;

   882     TFileName fullName;

   883 

   884     // Connect to file server

   885 	User::LeaveIfError( fsSession.Connect() ); // Start session

   886 	CleanupClosePushL( fsSession );

   887 

   888     TDriveList drivelist; 

   889 	User::LeaveIfError( fsSession.DriveList(drivelist) );

   890 	// A TDriveList (the list of available drives), is an array of 

   891 	// 26 bytes. Each byte with a non zero value signifies that the 

   892 	// corresponding drive is available.

   893 

   894     // 0x10000079, 0x1000008d, 0x101FB3E7

   895     TUidType anEntryUid( KDynamicLibraryUid, 

   896                          KSharedLibraryUid, 

   897                          KUidTestModule ); 

   898     TInt driveNumber; 

   899 	TChar driveLetter;

   900 

   901     CDir* testModules = NULL;

   902     

   903 	for( driveNumber=EDriveA; driveNumber<=EDriveZ; driveNumber++ )

   904 		{

   905 		if( !drivelist[driveNumber] ) 

   906 			{

   907 			// If drive-list entry is zero, drive is not available

   908 			continue;

   909 			}

   910         User::LeaveIfError(fsSession.DriveToChar(driveNumber,driveLetter));

   911 

   912         libDirectory.Zero();

   913         libDirectory.Append( driveLetter );

   914         libDirectory.Append( _L(":\\sys\\bin\\*") );

   915         

   916         iLogger->Log( _L("Searching modules from %S"), &libDirectory );

   917 

   918         fsSession.GetDir( libDirectory, anEntryUid, ESortNone, testModules );

   919 

   920         if( !testModules )

   921             {

   922             // Continue if no test modules found

   923             continue;

   924             }

   925         TInt count = testModules->Count();

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

   927             {           

   928             fullName = (*testModules)[i].iName;

   929             

   930             fullName.LowerCase();

   931             // Remove optional '.DLL' from file name

   932             TParse parse;

   933             parse.Set( fullName, NULL, NULL );

   934     

   935             if ( parse.Ext() == _L(".dll") )

   936                 {

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

   938                 fullName.Delete( fullName.Length()-len, len );

   939                 }

   940                         

   941             // Exclude internal test modules (testcombiner, testscripter, suevent)

   942             _LIT(KTestCombiner, "testcombiner");

   943             _LIT(KTestScripter, "testscripter");

   944             _LIT(KSUEvent, "suevent");

   945             if(fullName != KTestCombiner && fullName != KSUEvent && fullName != KTestScripter)

   946                 { 

   947                 HBufC* name = fullName.AllocLC();

   948                 iLogger->Log( _L("Found: %S"), name );

   949                 User::LeaveIfError( aModuleNames.Append( name ) );

   950                 CleanupStack::Pop( name );

   951                 }

   952             }

   953         delete testModules;

   954         testModules = NULL;

   955 		}

   956     

   957     CleanupStack::PopAndDestroy(); // fsSession 

   958     

   959     } 

   960     

   961 /*

   962 -------------------------------------------------------------------------------

   963 

   964     Class: CUIStore

   965 

   966     Method: CreateTestSet

   967 

   968     Description: Create new test set.

   969 

   970     Parameters: TDesC& aSetName: in: test set name (Max length is KMaxName)

   971     

   972     Return Values: Symbian OS error code

   973 

   974     Errors/Exceptions: None

   975 

   976     Status: Draft

   977 

   978 -------------------------------------------------------------------------------

   979 */ 

   980 EXPORT_C TInt CUIStore::CreateTestSet( const TDesC& aSetName )

   981     {

   982     

   983     TPtrC setName;

   984     TFileName tmp;

   985     TInt ret = ParseTestSetName( aSetName, setName, tmp );

   986     if( ret != KErrNone )

   987         {

   988         return ret;

   989         }

   990         

   991     CTestSetInfo* setInfo = NULL;

   992     if( FindSetByName( setName, setInfo ) == KErrNone )

   993         {

   994         return KErrAlreadyExists;

   995         }

   996     TRAPD( err, 

   997         setInfo = CTestSetInfo::NewL( setName );

   998         );

   999     if( err != KErrNone )

  1000         {

  1001         return err;

  1002         }

  1003     if( iTestSets.Append( setInfo ) != KErrNone )

  1004         {

  1005         delete setInfo;

  1006         return KErrNoMemory;

  1007         }

  1008             

  1009     return KErrNone;

  1010     

  1011     }

  1012     

  1013 /*

  1014 -------------------------------------------------------------------------------

  1015 

  1016     Class: CUIStore

  1017 

  1018     Method: RemoveTestSet

  1019 

  1020     Description: Remove active test set.

  1021 

  1022     Parameters: TDesC& aSetName: in: test set name (Max length is KMaxName)

  1023     

  1024     Return Values: Symbian OS error code

  1025 

  1026     Errors/Exceptions: None

  1027 

  1028     Status: Draft

  1029 

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

  1031 */ 

  1032 EXPORT_C TInt CUIStore::RemoveTestSet( const TDesC& aSetName )

  1033     {

  1034     TInt err = UnloadTestSet( aSetName );

  1035     if ( err != KErrNone )

  1036         {

  1037         return err;

  1038         }

  1039     

  1040     TFileName setfile;

  1041     setfile.Append(KUIStoreDefaultDir);

  1042     setfile.Append(aSetName);

  1043     RFs fs;

  1044     err = fs.Connect();

  1045     if( err != KErrNone )

  1046         {

  1047         fs.Close();

  1048         return err;

  1049         }

  1050     err = fs.Delete( setfile );

  1051     if ( err != KErrNone )

  1052         {

  1053         fs.Close();

  1054         return err;    

  1055         }

  1056     

  1057     return KErrNone;   

  1058     }

  1059 

  1060 /*

  1061 -------------------------------------------------------------------------------

  1062 

  1063     Class: CUIStore

  1064 

  1065     Method: UnloadTestSet

  1066 

  1067     Description: Unloads active test set.

  1068 

  1069     Parameters: TDesC& aSetName: in: test set name (Max length is KMaxName)

  1070     

  1071     Return Values: Symbian OS error code

  1072 

  1073     Errors/Exceptions: None

  1074 

  1075     Status: Draft

  1076 

  1077 -------------------------------------------------------------------------------

  1078 */ 

  1079 EXPORT_C TInt CUIStore::UnloadTestSet( const TDesC& aSetName )

  1080     {    

  1081     TPtrC setName;

  1082     TFileName tmp;

  1083     TInt ret = ParseTestSetName( aSetName, setName, tmp );

  1084     if( ret != KErrNone )

  1085         {

  1086         return ret;

  1087         }

  1088     

  1089     TInt count = iTestSets.Count();

  1090     TInt index = 0;

  1091     for( ; index < count; index++ )

  1092         {

  1093         if( iTestSets[index]->Name() == setName )

  1094             {

  1095             break;

  1096             }

  1097         }

  1098     if( index == count ) 

  1099         { 

  1100         return KErrNotFound;

  1101         }

  1102 

  1103     CTestSetInfo* setInfo = iTestSets[index];

  1104     iTestSets.Remove( index );

  1105     

  1106     // If started test set keeps info about currently removed test set

  1107     // then remove also this info

  1108     CStartedTestSet *stset;

  1109     for(index = 0; index < iStartedTestSets.Count(); index++)

  1110         {

  1111         stset = iStartedTestSets[index];

  1112         if(stset->GetOriginalTestSet() == setInfo)

  1113             {

  1114             stset->NullOriginalTestSet();

  1115             }

  1116         }

  1117     

  1118     delete setInfo;

  1119     

  1120     return KErrNone;    

  1121     }

  1122 

  1123 /*

  1124 -------------------------------------------------------------------------------

  1125 

  1126     Class: CUIStore

  1127 

  1128     Method: TestSets

  1129 

  1130     Description: Query test sets.

  1131 

  1132     Parameters:RRefArray<CTestSetInfo>& aSetInfos: out: list of test sets

  1133     

  1134     Return Values: Symbian OS error code