/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: This module contains implementation of CUIStore
* and CModule class member functions.
*
*/
// INCLUDE FILES
#include <e32base.h>
#include <e32svr.h>
#include <f32file.h>
#include <e32uid.h>
#include <collate.h>
#include <StifLogger.h>
#include "Logging.h"
#include <stifinternal/UIStore.h>
#include <stifinternal/UIEngine.h>
#include <stifinternal/UIStoreContainer.h>
#include "UIStorePopup.h"
#include <stifinternal/UIEngineContainer.h>
// EXTERNAL DATA STRUCTURES
// EXTERNAL FUNCTION PROTOTYPES
// CONSTANTS
//@spe _LIT(KNameTxt,"TEST FRAMEWORK");
//@spe _LIT(KNameBase,"BASE");
_LIT( KUIStore, "CUiStore" );
_LIT( KUIStoreIf, "CUiStoreIf" );
//_LIT( KUIStoreDefaultDir, "C:\\TestFramework\\" );
_LIT( KUIStoreSetStart, "[TestSetStart]" );
_LIT( KUIStoreSetEnd, "[TestSetEnd]" );
_LIT( KUIStoreSetName, "TestSetName=" );
_LIT( KUIStoreSetCaseStart, "[TestSetCaseStart]" );
_LIT( KUIStoreSetCaseEnd, "[TestSetCaseEnd]" );
_LIT( KUIStoreCaseModuleName, "ModuleName=" );
_LIT( KUIStoreTestCaseTitle, "Title=" );
_LIT( KUIStoreTestCaseFile, "TestCaseFile=");
_LIT( KUIStoreTestCaseNum, "TestCaseNum=");
_LIT( KUIStoreCaseExpectedResult, "ExpectedResult=");
_LIT( KUIStoreCasePriority, "Priority=");
_LIT( KUIStoreCaseTimeout, "Timeout=");
_LIT( KUIStoreLastStartedCaseIndex, "LastStartedCaseIndex=");
_LIT( KUIStoreDefaultRebootFile, "TestFrameworkUIReboot.txt" );
_LIT( KUIStoreStartTest, "[StartTestCase]" );
_LIT( KUIStoreStartTestEnd, "[StartTestCaseEnd]" );
_LIT( KUIStoreCaseStatus, "TestCaseStatus=");
_LIT( KUIStoreCaseExecutionResult, "TestCaseExecutionResult=");
_LIT( KUIStoreCaseResult, "TestCaseResult=");
_LIT( KUIStoreCaseStartTime, "TestCaseStartTime=");
_LIT( KUIStoreCaseEndTime, "TestCaseEndTime=");
const TInt KRcpHeaderLen = 16;
const TInt KFixedStartedCaseIndex = 10;
// MACROS
#ifdef LOGGER
#undef LOGGER
#endif
#define LOGGER iLogger
// LOCAL CONSTANTS AND MACROS
static const TUid KUidTestModule = { 0x101FB3E7 };
// MODULE DATA STRUCTURES
// LOCAL FUNCTION PROTOTYPES
// FORWARD DECLARATIONS
// ==================== LOCAL FUNCTIONS =======================================
// None
// ================= MEMBER FUNCTIONS =========================================
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: NewL
Description: Construct the CUIStore class
Parameters: None
Return Values: CUIStore* New object
Errors/Exceptions: Leaves if memory allocation fails or
ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CUIStore* CUIStore::NewL( CUIStoreIf* aUIStoreIf )
{
CUIStore* self = new ( ELeave ) CUIStore( aUIStoreIf );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: ConstructL
Description: Second level constructor.
Construct the console
Construct module and case containers
Retrieve command line parameters
Connect to test engine
Parameters: None
Return Values: None
Errors/Exceptions: Leaves if memory allocation fails or fileserver or
test engine can't be connected.
Status: Draft
-------------------------------------------------------------------------------
*/
void CUIStore::ConstructL( )
{
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: CUIStore
Description: Constructor.
Initialize non-zero member variables.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CUIStore::CUIStore( CUIStoreIf* aUIStoreIf ):
iUIStoreIf( aUIStoreIf ),
iUpdateNeeded( ETrue ),
iActivePopupPriority( EPopupPriorityLow )
{
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: ~CUIStore
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CUIStore::~CUIStore( )
{
iFileList.ResetAndDestroy();
iFileList.Close();
iStartedTestSets.ResetAndDestroy();
iStartedTestSets.Close();
iStartedTestCases.ResetAndDestroy();
iStartedTestCases.Close();
iTestSets.ResetAndDestroy();
iTestSets.Close();
iTestCases.ResetAndDestroy();
iTestCases.Close();
iPopups.ResetAndDestroy();
iPopups.Close();
delete iUIEngine;
iUIEngine = 0;
}
/*
-------------------------------------------------------------------------------
Class: CStifTFwIf
Method: Open
Description: Open test engine.
Parameters: TDesC& aTestFrameworkIni: in: Initialization file to Test Framework
Return Values: Symbian OS error: Error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::Open( const TDesC& aTestFrameworkIni )
{
if( aTestFrameworkIni.Length() > KMaxFileName )
{
return KErrArgument;
}
TRAPD( err,
iUIEngine = CUIEngine::NewL( this );
);
if( err != KErrNone )
{
return err;
}
TFileName ini( aTestFrameworkIni );
// Check given ini file
TRAP( err, CheckIniL( ini ) );
// Store folder of initialization file to open it again when looking for filters
RDebug::Print(_L("CUIStore stores name of ini file [%S]"), &ini);
iTestFrameworkIni.Copy(ini);
return iUIEngine->Open( ini );
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: Close
Description: Close test engine.
Parameters: None
Return Values: TInt KErrNone: Always returned KErrNone
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::Close()
{
TInt ret = KErrNone;
if( iUIEngine != NULL )
{
ret = iUIEngine->Close();
delete iUIEngine;
iUIEngine = 0;
}
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: AddTestModule
Description: Add test module to module list of test engine
Parameters: TDesC& aModuleName: in: Testmodule, which is added to module list
TDesC& aIniFile: in: Initialization file to the test module
Return Values: Symbian OS error: Error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::AddTestModule( const TDesC& aModuleName,
const TDesC& aIniFile )
{
TInt ret = iUIEngine->AddTestModule( aModuleName, aIniFile );
RefreshAllCases();
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: RemoveTestModule
Description: Add test module to module list of test engine
Parameters: TDesC& aModuleName: in: Testmodule, which is removed of module list
Return Values: Symbian OS error: Error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::RemoveTestModule( const TDesC& aModuleName )
{
TInt ret = iUIEngine->RemoveTestModule( aModuleName );
RefreshAllCases();
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: AddTestCaseFile
Description: Add test case file to test case file list of test engine
Parameters: TDesC& aModuleName: in: Testmodule, which own test cases of test case list.
TDesC& aCaseFile: in: Test case list, which is added to test case list
Return Values: Symbian OS error: Error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::AddTestCaseFile( const TDesC& aModuleName,
const TDesC& aCaseFile )
{
TInt ret = iUIEngine->AddTestCaseFile( aModuleName, aCaseFile );
RefreshAllCases();
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: RemoveTestCaseFile
Description: Remove test case file of test case file list of test engine
Parameters: TDesC& aModuleName: in: Testmodule, which own test cases of test case list
TDesC& aCaseFile: in: Test case list, which is removed of test case list
Return Values: Symbian OS error: Error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::RemoveTestCaseFile( const TDesC& aModuleName,
const TDesC& aCaseFile )
{
TInt ret = iUIEngine->RemoveTestCaseFile( aModuleName, aCaseFile );
RefreshAllCases();
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: StartTestCase
Description: Start selected test case identified with CTestInfo.
anIndex contains index in StartedTestCase array,
which is valid only during execution of calling
function.
Parameters: const CTestInfo& aTestInfo: in: Test case info
TInt& anIndex: out: Index to StartedTestCaseArray returned
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::StartTestCase( const CTestInfo& aTestInfo,
TInt& anIndex )
{
CUIEngineContainer* container = NULL;
TInt ret = iUIEngine->StartTestCase( container, aTestInfo );
if( ret != KErrNone )
{
return ret;
}
CStartedTestCase* testCase = NULL;
TRAP( ret,
testCase = CStartedTestCase::NewL( aTestInfo, *container );
);
if( ret != KErrNone )
{
iUIEngine->AbortStartedTestCase( container );
return ret;
}
ret = iStartedTestCases.Append( testCase );
if( ret != KErrNone )
{
iUIEngine->AbortStartedTestCase( container );
delete testCase;
return ret;
}
anIndex = iStartedTestCases.Find( testCase );
if( anIndex < 0 )
{
User::Panic( KUIStore, KErrNotFound );
}
iUIStoreIf->Update( testCase, testCase->Status() );
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: TestCases
Description: Return array of existing test cases.
Parameters: RRefArray<CTestInfo>& aTestCases: out: Array of test cases
TDesC& aTestModule: in: Test module name (optional)
TDesC& aTestCaseFile: in: Test case file name (optional)
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::TestCases( RRefArray<CTestInfo>& aTestCases,
const TDesC& aTestModule,
const TDesC& aTestCaseFile )
{
TInt ret = UpdateCases();
if( ret != KErrNone )
{
return ret;
}
TInt count = iTestCases.Count();
for( TInt i = 0; i < count; i++ )
{
if( ( aTestModule.Length() > 0 ) &&
( iTestCases[i]->ModuleName() != aTestModule ) )
{
continue;
}
else if( ( aTestCaseFile.Length() > 0 ) &&
( iTestCases[i]->TestCaseFile() != aTestCaseFile ) )
{
continue;
}
aTestCases.Append( *iTestCases[i] );
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: StartedTestCaseL
Description: Return started (running/runned) test case
Parameters: CStartedTestCase& aTestCase: out: Test case information
TInt anIndex: in: test case index in StartedTestCaseArray
Return Values: Reference to CStartedTestCase object
Errors/Exceptions: Leaves if anIndex out of range
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C CStartedTestCase& CUIStore::StartedTestCaseL( TInt anIndex )
{
TInt count = iStartedTestCases.Count();
if( ( anIndex >= count ) ||
( anIndex < 0 ) )
{
User::Leave( KErrNotFound );
}
return *iStartedTestCases[anIndex];
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: StartedTestCases
Description: Return started (running/runned) test cases
Parameters: RRefArray<CStartedTestCase>& aTestCases: out: array of test cases
TExecutionStatus aStatus: in: test case status (optional)
TDesC& aTestModule: in: test module name (optional)
TDesC& aTestCaseFile: in: test case file name (optional)
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::StartedTestCases( RRefArray<CStartedTestCase>& aTestCases,
TInt aStatus,
const TDesC& aTestModule,
const TDesC& aTestCaseFile )
{
TInt count = iStartedTestCases.Count();
for( TInt i = 0; i < count; i++ )
{
if( ( aTestModule.Length() > 0 ) &&
( iStartedTestCases[i]->TestInfo().ModuleName() != aTestModule ) )
{
continue;
}
else if( ( aTestCaseFile.Length() > 0 ) &&
( iStartedTestCases[i]->TestInfo().TestCaseFile() != aTestCaseFile ) )
{
continue;
}
else if( ( aStatus != CUIStoreIf::EStatusAll) &&
!( iStartedTestCases[i]->Status() & aStatus ) )
{
continue;
}
if( aTestCases.Append( *iStartedTestCases[i] ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: Modules
Description: Return modules array
Parameters: RRefArray<CModule>& aTestModules: out: modules array
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::Modules( RRefArray<TDesC>& aTestModules )
{
TInt ret = UpdateCases();
if( ret != KErrNone )
{
return ret;
}
// Go through test cases and search if there are new modules
// and add them to aTestModules array
TInt caseCount = iTestCases.Count();
TInt moduleCount = 0;
TInt caseIndex = 0;
TInt moduleIndex = 0;
for ( caseIndex = 0; caseIndex < caseCount; caseIndex++ )
{
// First check modules
moduleCount = aTestModules.Count();
for ( moduleIndex = 0; moduleIndex < moduleCount; moduleIndex++ )
{
if( iTestCases[caseIndex]->ModuleName() ==
aTestModules[moduleIndex] )
{
break;
}
}
if ( moduleIndex == moduleCount )
{
// New module found
if( aTestModules.Append( iTestCases[caseIndex]->ModuleName() ) !=
KErrNone )
{
return KErrNoMemory;
}
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: TestCaseFiles
Description: Return test case files
Parameters: RRefArray<TDesC>& aTestCaseFiles: out: Array of test case files
TDesC& aTestModule: in: test module name (optional)
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::TestCaseFiles( RRefArray<TDesC>& aTestCaseFiles,
const TDesC& aTestModule )
{
TInt ret = UpdateCases();
if( ret != KErrNone )
{
return ret;
}
// Go through test cases and search if there are new test case files
// for specified test module and add them to aTestCaseFiles array
TInt caseCount = iTestCases.Count();
TInt fileCount = 0;
TInt caseIndex = 0;
TInt fileIndex = 0;
for ( caseIndex = 0; caseIndex < caseCount; caseIndex++ )
{
if( ( aTestModule.Length() > 0 ) &&
( aTestModule != iTestCases[caseIndex]->ModuleName() ) )
{
// Test case file is not for specified module
continue;
}
// First check modules
fileCount = aTestCaseFiles.Count();
for ( fileIndex = 0; fileIndex < fileCount; fileIndex++ )
{
if( iTestCases[caseIndex]->TestCaseFile() ==
aTestCaseFiles[fileIndex] )
{
break;
}
}
if ( fileIndex == fileCount )
{
// New test case file found
if( aTestCaseFiles.Append( iTestCases[caseIndex]->TestCaseFile() ) !=
KErrNone )
{
return KErrNoMemory;
}
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: LoadAllModules
Description: Loads all TestFramework test modules from \system\libs\ directories
of all drives. In Secure Platform from \sys\bin directories.
Parameters: None
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::LoadAllModules()
{
RPointerArray<TDesC> testModules;
TInt ret = ListAllModules( testModules );
if( ret == KErrNone )
{
for (TInt i= 0; i < testModules.Count(); i++)
{
iLogger->Log( _L("Add test module: %S"), testModules[i] );
ret = iUIEngine->AddTestModule( *testModules[i], KNullDesC );
if( ret != KErrNone )
{
iLogger->Log( _L("Add test module %S failed %d"),
testModules[i], ret );
break;
}
}
}
RefreshAllCases();
testModules.ResetAndDestroy();
testModules.Close();
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: ListAllModules
Description: Lists all TestFramework test modules from \system\libs\ directories
of all drives. In Secure Platform from \sys\bin directories.
Parameters: None
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::ListAllModules( RPointerArray<TDesC>& aModuleNames )
{
TRAPD( err, ListAllModulesL( aModuleNames ); );
return err;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: ListAllModulesL
Description: Lists all TestFramework test modules from \system\libs\ directories
of all drives. In Secure Platform from \sys\bin directories.
Parameters: None
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CUIStore::ListAllModulesL( RPointerArray<TDesC>& aModuleNames )
{
TFileName libDirectory;
RFs fsSession;
TFileName fullName;
// Connect to file server
User::LeaveIfError( fsSession.Connect() ); // Start session
CleanupClosePushL( fsSession );
TDriveList drivelist;
User::LeaveIfError( fsSession.DriveList(drivelist) );
// A TDriveList (the list of available drives), is an array of
// 26 bytes. Each byte with a non zero value signifies that the
// corresponding drive is available.
// 0x10000079, 0x1000008d, 0x101FB3E7
TUidType anEntryUid( KDynamicLibraryUid,
KSharedLibraryUid,
KUidTestModule );
TInt driveNumber;
TChar driveLetter;
CDir* testModules = NULL;
for( driveNumber=EDriveA; driveNumber<=EDriveZ; driveNumber++ )
{
if( !drivelist[driveNumber] )
{
// If drive-list entry is zero, drive is not available
continue;
}
User::LeaveIfError(fsSession.DriveToChar(driveNumber,driveLetter));
libDirectory.Zero();
libDirectory.Append( driveLetter );
libDirectory.Append( _L(":\\sys\\bin\\*") );
iLogger->Log( _L("Searching modules from %S"), &libDirectory );
fsSession.GetDir( libDirectory, anEntryUid, ESortNone, testModules );
if( !testModules )
{
// Continue if no test modules found
continue;
}
TInt count = testModules->Count();
for (TInt i= 0; i < count; i++)
{
fullName = (*testModules)[i].iName;
fullName.LowerCase();
// Remove optional '.DLL' from file name
TParse parse;
parse.Set( fullName, NULL, NULL );
if ( parse.Ext() == _L(".dll") )
{
const TInt len = parse.Ext().Length();
fullName.Delete( fullName.Length()-len, len );
}
// Exclude internal test modules (testcombiner, testscripter, suevent)
_LIT(KTestCombiner, "testcombiner");
_LIT(KTestScripter, "testscripter");
_LIT(KSUEvent, "suevent");
_LIT(KTEFTestModule, "TEFTestModule");
_LIT(KTEFTestModuleLite, "TEFTestModuleLite");
if(fullName != KTestCombiner && fullName != KSUEvent && fullName != KTestScripter&& fullName != KTEFTestModule && fullName != KTEFTestModuleLite)
{
HBufC* name = fullName.AllocLC();
iLogger->Log( _L("Found: %S"), name );
User::LeaveIfError( aModuleNames.Append( name ) );
CleanupStack::Pop( name );
}
}
delete testModules;
testModules = NULL;
}
CleanupStack::PopAndDestroy(); // fsSession
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: CreateTestSet
Description: Create new test set.
Parameters: TDesC& aSetName: in: test set name (Max length is KMaxName)
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::CreateTestSet( const TDesC& aSetName )
{
TPtrC setName;
TFileName tmp;
TInt ret = ParseTestSetName( aSetName, setName, tmp );
if( ret != KErrNone )
{
return ret;
}
CTestSetInfo* setInfo = NULL;
if( FindSetByName( setName, setInfo ) == KErrNone )
{
return KErrAlreadyExists;
}
TRAPD( err,
setInfo = CTestSetInfo::NewL( setName );
);
if( err != KErrNone )
{
return err;
}
if( iTestSets.Append( setInfo ) != KErrNone )
{
delete setInfo;
return KErrNoMemory;
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: RemoveTestSet
Description: Remove active test set.
Parameters: TDesC& aSetName: in: test set name (Max length is KMaxName)
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::RemoveTestSet( const TDesC& aSetName )
{
TPtrC setName;
TFileName tmp;
TInt ret = ParseTestSetName( aSetName, setName, tmp );
if( ret != KErrNone )
{
return ret;
}
TInt count = iTestSets.Count();
TInt index = 0;
for( ; index < count; index++ )
{
if( iTestSets[index]->Name() == setName )
{
break;
}
}
if( index == count )
{
return KErrNotFound;
}
CTestSetInfo* setInfo = iTestSets[index];
iTestSets.Remove( index );
// If started test set keeps info about currently removed test set
// then remove also this info
CStartedTestSet *stset;
for(index = 0; index < iStartedTestSets.Count(); index++)
{
stset = iStartedTestSets[index];
if(stset->GetOriginalTestSet() == setInfo)
{
stset->NullOriginalTestSet();
}
}
delete setInfo;
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: TestSets
Description: Query test sets.
Parameters:RRefArray<CTestSetInfo>& aSetInfos: out: list of test sets
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::TestSets( RRefArray<CTestSetInfo>& aSetInfos )
{
TInt count = iTestSets.Count();
for( TInt i=0; i<count; i++ )
{
if( aSetInfos.Append( *iTestSets[i] ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: TestSets
Description: Query test sets.
Parameters:RRefArray<CTestSetInfo>& aSetInfos: out: list of test sets
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C const CTestSetInfo& CUIStore::TestSetL( const TDesC& aSetName )
{
TPtrC setName;
TFileName tmp;
User::LeaveIfError( ParseTestSetName( aSetName, setName, tmp ) );
CTestSetInfo* setInfo = NULL;
User::LeaveIfError( FindSetByName( setName, setInfo ) );
return *setInfo;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: AddToTestSet
Description: Add test case to test set.
Parameters: TDesC& aSetName: out: test set name
CTestInfo& aTestInfo: in: test case to add
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::AddToTestSet( const TDesC& aSetName,
const CTestInfo& aTestInfo )
{
TPtrC setName;
TFileName tmp;
TInt ret = ParseTestSetName( aSetName, setName, tmp );
if( ret != KErrNone )
{
return ret;
}
CTestSetInfo* setInfo = NULL;
ret = FindSetByName( setName, setInfo );
if( ret != KErrNone )
{
return ret;
}
return setInfo->AddTestCase( aTestInfo );
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: InsertToTestSet
Description: Insert test case to test set.
Parameters: TDesC& aSetName: out: test set name
CTestInfo& aTestInfo: in: test case to add
TInt aPos: in: position to add
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::InsertToTestSet( const TDesC& aSetName,
const CTestInfo& aTestInfo,
TInt aPos )
{
TPtrC setName;
TFileName tmp;
TInt ret = ParseTestSetName( aSetName, setName, tmp );
if( ret != KErrNone )
{
return ret;
}
CTestSetInfo* setInfo = NULL;
ret = FindSetByName( setName, setInfo );
if( ret != KErrNone )
{
return ret;
}
return setInfo->InsertTestCase( aTestInfo, aPos );
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: RemoveFromTestSet
Description: Remove test case from test set.
Parameters: TDesC& aSetName: out: test set name
CTestInfo& aTestInfo: in: test case to remove
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::RemoveFromTestSet( const TDesC& aSetName,
const CTestInfo& aTestInfo )
{
TPtrC setName;
TFileName tmp;
TInt ret = ParseTestSetName( aSetName, setName, tmp );
if( ret != KErrNone )
{
return ret;
}
CTestSetInfo* setInfo = NULL;
ret = FindSetByName( setName, setInfo );
if( ret != KErrNone )
{
return ret;
}
return setInfo->RemoveTestCase( aTestInfo );
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: SaveTestSet
Description: Save test set. Deprecated, SaveTestSet2 to be used instead
Parameters: TDesC&: out: test set name
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::SaveTestSet( const TDesC& /* aSetName */ )
{
return KErrNotSupported;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: SaveTestSet2
Description: Save test set.
Parameters: TDes& aSetName: out: test set name
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::SaveTestSet2( TDes& aSetName )
{
TPtrC setName;
TFileName tmp;
TTime current;
TDateTime date_rep;
current.HomeTime();
date_rep = current.DateTime();
TBuf<32> currSetName;
_LIT(f_ext,".set");
//create "test set name" string
currSetName.AppendNum(date_rep.Year());
currSetName.Append('_');
currSetName.AppendNum(date_rep.Month()+1); // Incrimination necessary, because Day and Month fields of TDateTime class are 0 based
currSetName.Append('_');
currSetName.AppendNum(date_rep.Day()+1);
currSetName.Append('_');
currSetName.AppendNum(date_rep.Hour());
currSetName.Append('_');
currSetName.AppendNum(date_rep.Minute());
currSetName.Append('_');
currSetName.AppendNum(date_rep.Second());
currSetName.Append(f_ext);
TInt ret = ParseTestSetName( aSetName, setName, tmp );
if( ret != KErrNone )
{
return ret;
}
CTestSetInfo* setInfo = NULL;
ret = FindSetByName( setName, setInfo );
if( ret != KErrNone )
{
return ret;
}
TRAPD( err,
SaveTestSetL( *setInfo, currSetName );
);
aSetName.Copy(currSetName);
return err;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: LoadTestSet
Description: Load test set.
Parameters: TDesC& aSetName: out: test set name
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::LoadTestSet( const TDesC& aSetName )
{
TPtrC setName;
TFileName tmp;
TInt ret = ParseTestSetName( aSetName, setName, tmp );
if( ret != KErrNone )
{
return ret;
}
TRAPD( err,
LoadTestSetL( setName, aSetName );
);
if( err != KErrNone && err != KErrAlreadyExists )
{
RemoveTestSet( setName );
}
return err;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: UpdateTestSet
Description: Updates (on storage) earlier saved test set.
Parameters: CTestSetInfo& aSetInfo: in: test set
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Approved
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::UpdateTestSet(CTestSetInfo& aSetInfo)
{
TRAPD(err,
UpdateTestSetL(aSetInfo, aSetInfo.Name());
);
return err;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: StartTestSet
Description: Start selected test set identified with CTestSetInfo.
Parameters: const CTestSetInfo& aTestSetInfo: in: Started test set
TInt& anIndex: out index in StartedTestSet array,
which is valid only during execution of calling
function.
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::StartTestSet( const CTestSetInfo& aTestSetInfo,
TInt& anIndex,
CStartedTestSet::TSetType aType )
{
return StartTestSet(aTestSetInfo, anIndex, aType, EFalse);
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: StartTestSet
Description: Start selected test set identified with CTestSetInfo.
Parameters: const CTestSetInfo& aTestSetInfo: in: Started test set
TInt& anIndex: out index in StartedTestSet array,
which is valid only during execution of calling
function.
TSetType aType: sequential or paraller
TBool aNotExecutedCasesMode: only test case which haven't been
executed yet
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Approved
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::StartTestSet( const CTestSetInfo& aTestSetInfo,
TInt& anIndex,
CStartedTestSet::TSetType aType,
TBool aNotStartedCasesMode )
{
TInt ret = KErrNone;
CStartedTestSet* set = NULL;
TRAPD( err,
set = CStartedTestSet::NewL( this, aTestSetInfo, aType );
);
if( err != KErrNone )
{
return err;
}
if( iStartedTestSets.Append( set ) != KErrNone )
{
delete set;
return KErrNoMemory;
}
// Set mode in which only still not executed test cases will be run.
// It applies only to sequential execution.
set->SetNotStartedCasesMode(aNotStartedCasesMode);
ret = set->StartNext();
anIndex = iStartedTestSets.Find( set );
if( anIndex < 0 )
{
User::Panic( KUIStore, KErrNotFound );
}
// Check that testset starting was successful
if( ret != KErrNone )
{
iStartedTestSets.Remove( anIndex );
anIndex = KErrNotFound; // safety
delete set;
return ret;
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: AbortTestSet
Description: Abort running test set.
Parameters: None
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::AbortTestSet( CStartedTestSet& aSetInfo )
{
return aSetInfo.Abort();
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: StartedTestSetL
Description: Return started (running/runned) test set.
Parameters: TInt anIndex: out index in StartedTestSet array
Return Values: CStartedTestSet&: reference to test set
Errors/Exceptions: Leaves on error.
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C CStartedTestSet& CUIStore::StartedTestSetL( TInt anIndex)
{
if( anIndex < 0 ||
anIndex >= iStartedTestSets.Count() )
{
User::Leave( KErrNotFound );
}
return *iStartedTestSets[ anIndex ];
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: StartedTestSets
Description: Return started (running/runned) test cases
Parameters: RRefArray<CStartedTestSet>& aTestCases: out: list of test sets
TInt aStatus: in: status of queried sets
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::StartedTestSets( RRefArray<CStartedTestSet>& aTestSets,
TInt aStatus )
{
TInt count = iStartedTestSets.Count();
for( TInt i = 0; i < count; i++ )
{
if( ( aStatus != CUIStoreIf::ESetAll) &&
!( iStartedTestSets[i]->Status() & aStatus ) )
{
continue;
}
if( aTestSets.Append( *iStartedTestSets[i] ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: LoadSavedTestCases
Description: Load saved testcases.
Parameters: None
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::LoadSavedTestCases()
{
TRAPD( err,
LoadExecutedTestCasesL();
);
return err;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: GetTestSetsList
Description: Returns menu item text.
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C TInt CUIStore::GetTestSetsList( RRefArray<TDesC>& aArray )
{
RFs fileReader;
CDir* dirContents = NULL;
_LIT(KSetPattern,".set");
TInt entNum = 0;
TInt ret = 0;
HBufC* fName = NULL;
ret = fileReader.Connect();
if (ret != KErrNone)
return ret;
ret = fileReader.GetDir(KUIStoreDefaultDir,
KEntryAttNormal | KEntryAttHidden | KEntryAttSystem,
ESortByName | EDirsFirst | EAscending,
dirContents);
fileReader.Close();
if (ret != KErrNone)
{
delete dirContents;
return ret;
}
entNum = dirContents->Count();
for (int i = 0;i<entNum;i++)
{
if ((!dirContents->operator[](i).IsDir())&&
dirContents->operator[](i).iName.Find(KSetPattern)!=KErrNotFound)
{
TRAPD( err, fName = HBufC::NewL(64) );
if( err != KErrNone )
{
delete dirContents;
return err;
}
*fName = dirContents->operator[](i).iName;
ret = iFileList.Append(fName);
if (ret != KErrNone)
{
delete fName;
delete dirContents;
return ret;
}
ret = aArray.Append(*fName);
if (ret != KErrNone)
{
delete fName;
delete dirContents;
return ret;
}
}
}
delete dirContents;
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: FindSetByName
Description: Finds test set by name.
Parameters: const TDesC& aSetName: in: set name
CTestSetInfo*& aSetInfo: out: pointer to test set
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::FindSetByName( const TDesC& aSetName,
CTestSetInfo*& aSetInfo )
{
TInt count = iTestSets.Count();
for( TInt i=0; i<count; i++ )
{
if( iTestSets[i]->Name() == aSetName )
{
aSetInfo = iTestSets[i];
return KErrNone;
}
}
return KErrNotFound;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: FindSetByCase
Description: Finds test set by name.
Parameters: const CStartedTestCase* aTestCase: in: running test case
CStartedTestSet*& aSet: out: set running test case
Return Values: KErrNotFound: test case is not runned by any test set
KErrNone: test case was runned by aSet
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::FindStartedSetByCase( const CStartedTestCase* aTestCase,
CStartedTestSet*& aSet )
{
TInt count = iStartedTestSets.Count();
for( TInt i=0; i<count; i++ )
{
if( iStartedTestSets[i]->IsRunning( aTestCase ) )
{
aSet = iStartedTestSets[i];
return KErrNone;
}
}
return KErrNotFound;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: LoadTestSetL
Description: Load test set.
Parameters: TDesC& aSetName: out: test set name
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CUIStore::LoadTestSetL( const TDesC& aSetName, const TDesC& aSetFileName )
{
TPtrC tmp;
TInt num;
TInt high;
TInt64 interval;
CStifParser* parser = NULL;
TRAPD( err,
parser = CStifParser::NewL( _L(""), aSetFileName );
);
if( err != KErrNone )
{
parser = CStifParser::NewL( KUIStoreDefaultDir, aSetName );
}
CleanupStack::PushL( parser );
CStifSectionParser* section =
parser->SectionL( KUIStoreSetStart, KUIStoreSetEnd );
CleanupStack::PushL( section );
CStifItemParser* item = section->GetItemLineL( KUIStoreSetName );
CleanupStack::PushL( item );
User::LeaveIfError( item->GetString( KUIStoreSetName, tmp ) );
// get the standard method
TCollationMethod method = *Mem::CollationMethodByIndex(0);
// ignore case
method.iFlags |= TCollationMethod::EFoldCase;
TInt compare = aSetName.CompareC( tmp, 3, &method );
if( compare != KErrNone )
{
User::LeaveIfError( KErrNotFound );
}
CleanupStack::PopAndDestroy( item );
// Get started test case (if possible)
TUint lastStartedCaseIndex = 0;
item = section->GetItemLineL(KUIStoreLastStartedCaseIndex);
if(item)
{
CleanupStack::PushL(item);
TInt r = item->GetInt(KUIStoreLastStartedCaseIndex, lastStartedCaseIndex);
CleanupStack::PopAndDestroy(item);
if(r != KErrNone)
{
__TRACE(KInit, (_L("Could not read [%S] from test set file. Result [%d]."), &KUIStoreLastStartedCaseIndex, r));
}
}
else
{
__TRACE(KInit, (_L("Could not find [%S] from test set file."), &KUIStoreLastStartedCaseIndex));
}
User::LeaveIfError( CreateTestSet( aSetName ) );
CTestSetInfo* setInfo = NULL;
User::LeaveIfError( FindSetByName( aSetName, setInfo ) );
// Update started case
setInfo->SetLastStartedCaseIndex(lastStartedCaseIndex);
CTestInfo* testInfo = CTestInfo::NewL();
CleanupStack::PushL( testInfo );
CStifSectionParser* subSection =
section->SubSectionL( KUIStoreSetCaseStart, KUIStoreSetCaseEnd );
while( subSection )
{
CleanupStack::PushL( subSection );
// Get module name
// Mandatory, leave if not found
User::LeaveIfError(
subSection->GetLine( KUIStoreCaseModuleName, tmp, ENoTag ) );
testInfo->SetModuleName( tmp );
// Get test case title
// Mandatory, leave if not found
User::LeaveIfError(
subSection->GetLine( KUIStoreTestCaseTitle, tmp, ENoTag ) );
testInfo->SetTestCaseTitle( tmp );
// Get test case file
num = subSection->GetLine( KUIStoreTestCaseFile, tmp, ENoTag );
if( ( num == KErrNone ) &&
( tmp.Length() > 0 ) )
{
// Optional
testInfo->SetTestCaseFile( tmp );
}
// Get test case number
item = subSection->GetItemLineL( KUIStoreTestCaseNum );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetInt( KUIStoreTestCaseNum, num ));
testInfo->SetTestCaseNumber( num );
CleanupStack::PopAndDestroy( item );
// Get test case priority
item = subSection->GetItemLineL( KUIStoreCasePriority );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetInt( KUIStoreCasePriority, num ));
testInfo->SetPriority( num );
CleanupStack::PopAndDestroy( item );
// Get test case timeout
item = subSection->GetItemLineL( KUIStoreCaseTimeout );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetInt( KUIStoreCaseTimeout, num ));
User::LeaveIfError( item->GetNextInt( high ));
//@js<--remove--> interval.Set( high, num );
interval = MAKE_TINT64( high, num );
TTimeIntervalMicroSeconds timeout( interval );
testInfo->SetTimeout( timeout );
CleanupStack::PopAndDestroy( item );
User::LeaveIfError( setInfo->AddTestCase( *testInfo ) );
CleanupStack::PopAndDestroy( subSection );
subSection =
section->NextSubSectionL( KUIStoreSetCaseStart, KUIStoreSetCaseEnd );
}
CleanupStack::PopAndDestroy( testInfo );
CleanupStack::PopAndDestroy( section );
CleanupStack::PopAndDestroy( parser );
const RRefArray<const CTestInfo>& testCases = setInfo->TestCases();
LoadTestModulesAndTestCaseFilesL( testCases );
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: SaveTestSetL
Description: Save test set.
Parameters: CTestSetInfo& aSetInfo: in: test set
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Approved
-------------------------------------------------------------------------------
*/
void CUIStore::SaveTestSetL( CTestSetInfo& aSetInfo, const TDesC& aSetFileName )
{
//Extract path
TParse p;
p.Set(aSetFileName, NULL, NULL);
TPtrC path = p.DriveAndPath(); // gives path for test set
TPtrC fn = p.NameAndExt(); // gives filename with extension
if(path.Length() == 0)
{
path.Set(KUIStoreDefaultDir);
}
//Create file server
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
//Create or open file
RFile file;
TFileName filename = path;
filename.Append(fn);
TInt r = file.Replace(fs, filename, EFileWrite);
if(r != KErrNone)
{
User::Leave(r);
}
else
{
CleanupClosePushL(file);
RBuf buffer;
buffer.Create(256);
CleanupClosePushL(buffer);
// Saving
buffer.Format(_L("%S"), &KUIStoreSetStart);
WriteLineL(file, buffer);
buffer.Format(_L("%S %S"), &KUIStoreSetName,&aSetFileName);
WriteLineL(file, buffer);
// Saving test set causes reset of index
aSetInfo.SetLastStartedCaseIndex(0);
buffer.Format(_L("%S "), &KUIStoreLastStartedCaseIndex);
buffer.AppendNumFixedWidth(aSetInfo.GetLastStartedCaseIndex(), EDecimal, KFixedStartedCaseIndex);
WriteLineL(file, buffer);
// Saving test cases
TInt count = aSetInfo.TestCases().Count();
for(TInt i = 0; i < count; i++)
{
WriteLineL(file, KNullDesC);
buffer.Format(_L("%S"), &KUIStoreSetCaseStart);
WriteLineL(file, buffer);
buffer.Format(_L("%S %S"), &KUIStoreCaseModuleName, &aSetInfo.TestCases()[i].ModuleName());
WriteLineL(file, buffer);
buffer.Format(_L("%S %S"), &KUIStoreTestCaseTitle, &aSetInfo.TestCases()[i].TestCaseTitle());
WriteLineL(file, buffer);
if(aSetInfo.TestCases()[i].TestCaseFile().Length() > 0)
{
buffer.Format(_L("%S %S"), &KUIStoreTestCaseFile, &aSetInfo.TestCases()[i].TestCaseFile());
WriteLineL(file, buffer);
}
buffer.Format(_L("%S %d"), &KUIStoreTestCaseNum, aSetInfo.TestCases()[i].TestCaseNum());
WriteLineL(file, buffer);
buffer.Format(_L("%S %d"), &KUIStoreCasePriority, aSetInfo.TestCases()[i].Priority());
WriteLineL(file, buffer);
buffer.Format(_L("%S %d %d"), &KUIStoreCaseTimeout, I64LOW(aSetInfo.TestCases()[i].Timeout().Int64()),
I64HIGH(aSetInfo.TestCases()[i].Timeout().Int64()));
WriteLineL(file, buffer);
buffer.Format(_L("%S %d"), &KUIStoreCaseExpectedResult, aSetInfo.TestCases()[i].ExpectedResult());
WriteLineL(file, buffer);
buffer.Format(_L("%S"), &KUIStoreSetCaseEnd);
WriteLineL(file, buffer);
}
WriteLineL(file, KNullDesC);
buffer.Format(_L("%S"), &KUIStoreSetEnd);
WriteLineL(file, buffer);
CleanupStack::PopAndDestroy(&buffer);
CleanupStack::PopAndDestroy(&file);
}
CleanupStack::PopAndDestroy(&fs);
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: UpdateTestSetL
Description: Updates information in test set file.
Parameters: CTestSetInfo& aSetInfo: in: test set
Return Values: Symbian OS error code
Errors/Exceptions: Leaves when writing to file fails
Leaves when file.seek fails
Leaves when can't connect to file server
Status: Approved
-------------------------------------------------------------------------------
*/
void CUIStore::UpdateTestSetL(CTestSetInfo& aSetInfo, const TDesC& aSetFileName)
{
// Get path
TParse p;
p.Set(aSetFileName, NULL, NULL);
TPtrC path = p.DriveAndPath(); // gives path for test set
TPtrC fn = p.NameAndExt(); // gives filename with extension
if(path.Length() == 0)
{
path.Set(KUIStoreDefaultDir);
}
//Create file server
RFs fs;
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
//Create or open file
RFile file;
TFileName filename = path;
filename.Append(fn);
TInt foundpos = KErrNotFound;
TInt r = file.Open(fs, filename, EFileWrite);
if(r != KErrNone)
{
User::Leave(r);
}
else
{
CleanupClosePushL(file);
//Search for line
RBuf buffer;
buffer.Create(256);
CleanupClosePushL(buffer);
//Prepare file
TInt pos = 0;
User::LeaveIfError(file.Seek(ESeekStart, pos));
//Read file
ReadLineL(file, buffer);
while(buffer.Length() > 0)
{
// Keep remembering current position
if(buffer.Find(KUIStoreLastStartedCaseIndex) == 0)
{
foundpos = pos;
break;
}
// What is current position
pos = 0;
User::LeaveIfError(file.Seek(ESeekCurrent, pos));
// Read next line from file
ReadLineL(file, buffer);
}
if(foundpos != KErrNotFound)
{
// Position was found. Just update that line (save index of last
// started test case)
RBuf8 b;
b.Create(40);
CleanupClosePushL(b);
b.Copy(KUIStoreLastStartedCaseIndex);
b.Append(_L8(" "));
b.AppendNumFixedWidth(aSetInfo.GetLastStartedCaseIndex(), EDecimal, KFixedStartedCaseIndex);
User::LeaveIfError(file.Seek(ESeekStart, foundpos));
User::LeaveIfError(file.Write(b));
CleanupStack::PopAndDestroy(&b);
}
CleanupStack::PopAndDestroy(&buffer);
CleanupStack::PopAndDestroy(&file);
}
CleanupStack::PopAndDestroy(&fs);
if(foundpos == KErrNotFound)
{
// Position of KUIStoreLastStartedCaseIndex could not be found.
// Store the whole file.
SaveTestSetL(aSetInfo, aSetFileName);
}
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: ReadLineL
Description: Read the whole line from the file. If there is enough space,
the whole content of line will be returned in buffer.
Parameters: RFile& file: in: file to be read
TDes8& buffer: out: buffer to be returned
Return Values: None
Errors/Exceptions: Leaves if RFile::Read method fails
Status: Approved
-------------------------------------------------------------------------------
*/
void CUIStore::ReadLineL(RFile &file, TDes& buffer)
{
TBuf8<1> c;
TBuf<1> c16;
buffer.Copy(KNullDesC);
User::LeaveIfError(file.Read(c));
while(c.Length() > 0)
{
// There is still place to write to the dest buffer
if(buffer.Length() < buffer.MaxLength())
{
c16.Copy(c);
buffer.Append(c16);
}
// Stop reading if end of line
if(c[0] == 0x0A)
{
break;
}
User::LeaveIfError(file.Read(c));
}
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: WriteLineL
Description: Write given line to the file and adds end of line.
Parameters: RFile& file: in: file to be written
TDesC& buffer: in: buffer to be written
Return Values: None
Errors/Exceptions: Leaves if RFile::Write method fails
Status: Approved
-------------------------------------------------------------------------------
*/
void CUIStore::WriteLineL(RFile &file, const TDesC& buffer)
{
if(buffer.Length() > 0)
{
// Create 8-bit buffer
RBuf8 buf;
buf.Create(buffer.Length());
CleanupClosePushL(buf);
buf.Copy(buffer);
// Write buffer to file + end of line
User::LeaveIfError(file.Write(buf));
// Delete 8-bit buffer
CleanupStack::PopAndDestroy(&buf);
}
// Write end of line
TBuf8<2> eoline;
eoline.Copy(_L("\r\n"));
User::LeaveIfError(file.Write(eoline));
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: LoadTestModulesL
Description: Load test modules.
Parameters: CTestSetInfo& aSetInfo: in: test set
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CUIStore::LoadTestModulesAndTestCaseFilesL(
const RRefArray<const CTestInfo>& aTestCases )
{
RRefArray<TDesC> testCaseFiles;
RRefArray<TDesC> testModules;
CleanupClosePushL( testCaseFiles );
CleanupClosePushL( testModules );
User::LeaveIfError( Modules( testModules ) );
TInt cCount = aTestCases.Count();
TInt mCount = 0;
TInt mInd=0;
TInt fCount = 0;
TInt fInd=0;
for( TInt cInd=0; cInd<cCount; cInd++ )
{
mCount = testModules.Count();
for( mInd=0; mInd<mCount; mInd++ )
{
if( aTestCases[cInd].ModuleName() == testModules[mInd] )
{
// Test module already loaded
break;
}
}
if( mInd == mCount )
{
// Not found, load test module
if( AddTestModule( aTestCases[cInd].ModuleName() ) == KErrNone )
{
User::LeaveIfError(
testModules.Append( aTestCases[cInd].ModuleName() ) );
}
}
if( aTestCases[cInd].TestCaseFile().Length() == 0 )
{
// Test case file is not used, continue
continue;
}
testCaseFiles.Reset();
User::LeaveIfError(
TestCaseFiles( testCaseFiles, aTestCases[cInd].ModuleName() ));
fCount = testCaseFiles.Count();
for( fInd=0; fInd<fCount; fInd++ )
{
if( aTestCases[cInd].TestCaseFile() == testCaseFiles[fInd] )
{
// Testcasefile already loaded
break;
}
}
if( fInd == fCount )
{
// Load test module
if( AddTestCaseFile( aTestCases[cInd].ModuleName(),
aTestCases[cInd].TestCaseFile() ) == KErrNone )
{
User::LeaveIfError(
testCaseFiles.Append( aTestCases[cInd].TestCaseFile() ) );
}
}
}
CleanupStack::PopAndDestroy(); // testModules
CleanupStack::PopAndDestroy(); // testCaseFiles
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: TestExecuted
Description: Test case executed callback from UI engine.
Parameters: CUIEngineContainer* const aContainer: in: Execution container
TFullTestResult& aFullTestResult: in: test result
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CUIStore::TestExecuted ( CUIEngineContainer* aContainer,
TFullTestResult& aFullTestResult )
{
CStartedTestCase* testCase = NULL;
if( FindByContainer( aContainer, testCase ) != KErrNone )
{
__TRACE( KError, ( CStifLogger::EError, _L("CUIStore::TestExecuted: Not found")));
return;
}
CStartedTestSet* set = NULL;
TInt setStatus = 0;
if( FindStartedSetByCase( testCase, set ) == KErrNone )
{
setStatus = set->Status();
set->TestCompleted( testCase, aFullTestResult );
setStatus |= set->Status();
}
// Check and delete all pending popup windows for test case
TInt count = iPopups.Count();
for( TInt i = 0; i<count; i++ )
{
if( iPopups[i]->Container() == aContainer )
{
delete iPopups[i];
iPopups.Remove( i );
}
}
// Get old status
TInt status = testCase->Status();
// Set result
testCase->SetResult( aFullTestResult );
// Get new status
status |= testCase->Status();
// Add set status flags
status |= setStatus;
iUIStoreIf->Update( testCase, status );
return;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: PrintProg
Description: Progress information from test case execution,
callback from UI engine.
Parameters: CUIEngineContainer* const aContainer: in: Execution container
TTestProgress& aProgress: in: print info
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::PrintProg ( CUIEngineContainer* aContainer,
TTestProgress& aProgress )
{
if( aContainer == NULL )
{
return KErrArgument;
}
if( ( aProgress.iDescription.Length() == 0 ) &&
( aProgress.iText.Length() == 0 ) )
{
return KErrArgument;
}
CStartedTestCase* testCase = NULL;
if( FindByContainer( aContainer, testCase ) != KErrNone )
{
__TRACE( KError, ( CStifLogger::EError, _L("CUIStore::TestExecuted: Not found")));
return KErrNotFound;
}
TInt position = KErrNotFound;
TInt smallPos = KErrNotFound;
// Search the array to find the position
const TInt count = testCase->PrintArray().Count();
for (TInt i = 0; i < count; i++)
{
// Check if that item is already on list
if ( testCase->PrintArray()[i]->iDescription == aProgress.iDescription &&
testCase->PrintArray()[i]->iPosition == aProgress.iPosition )
{
// Set it to be updated
position = i;
break;
}
// Found a smaller priority item from list
if ( aProgress.iPosition < testCase->PrintArray()[i]->iPosition )
{
smallPos = i;
break;
}
}
// Either update item in array or add new item to array
if ( position != KErrNotFound )
{
// Replace existing text
testCase->PrintArray()[position]->ReplaceTextL( aProgress );
}
else
{
CTestProgress* prog = NULL;
TRAPD( err,
// Allocate new
prog = CTestProgress::NewL( aProgress );
);
if( err != KErrNone )
{
return err;
}
if ( smallPos != KErrNotFound )
{
if( testCase->PrintArray().Insert( prog, smallPos ) != KErrNone )
{
delete prog;
return KErrNoMemory;
}
}
else
{
if( testCase->PrintArray().Append( prog ) != KErrNone )
{
delete prog;
return KErrNoMemory;
}
}
}
iUIStoreIf->Update( testCase, CUIStoreIf::EPrintUpdate );
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: PrintProg
Description: Error information from Test framework,
callback from UI engine.
Parameters: CUIEngineContainer* const aContainer: in: Execution container
TErrorNotification& aError: in: error info
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::ErrorPrint( TErrorNotification& aError )
{
if( aError.iText.Length() == 0 )
{
return KErrArgument;
}
iUIStoreIf->Error( aError );
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: RemoteMsg
Description: Remote protocol control messages handling.
Parameters: const TDesC& aMessage: in: Remote message
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::RemoteMsg( CUIEngineContainer* aContainer,
const TDesC& aMessage)
{
if( ( aMessage.Length() == 0 ) ||
( aContainer == NULL ) )
{
return KErrArgument;
}
TInt ret = KErrNone;
TInt error = KErrNone;
CStifTFwIfProt* msg = NULL;
CStifTFwIfProt* resp = NULL;
TRAPD( err, msg = CStifTFwIfProt::NewL(); );
if( err != KErrNone )
{
return err;
}
TRAP( err, resp = CStifTFwIfProt::NewL(); );
if( err != KErrNone )
{
delete msg;
return err;
}
// Parse received message
TRAP( err,
error = msg->SetL( aMessage )
);
if( err != KErrNone )
{
__TRACE( KError, ( _L( "CUIStore::RemoteMsg: message header parsing failed [%d]"), err ) );
delete msg;
delete resp;
return err;
}
// Create response
TRAP( err, resp->CreateL(); );
if( err != KErrNone )
{
delete msg;
delete resp;
return err;
}
resp->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgResponse );
if( error != KErrNone )
{
__TRACE( KError, ( _L( "CUIStore::RemoteMsg: message parsing failed [%d]"), error ) );
resp->AppendId( SETID( (TInt32)DevId(), 0 ) );
resp->AppendId( msg->SrcId() );
resp->Append( CStifTFwIfProt::MsgType, msg->iMsgType );
resp->Append( CStifTFwIfProt::RespParam, CStifTFwIfProt::ERespResult, error );
aContainer->RemoteReceive( resp->Message() );
// Error reported with protocol message, return success
delete msg;
delete resp;
return KErrNone;
}
TBool sendResp = ETrue;
switch( msg->iMsgType )
{
case CStifTFwIfProt::EMsgReserve:
{
// Check IDs
if( ( msg->SrcDevId() == 0 ) ||
( msg->SrcTestId() == 0 ) )
{
__TRACE( KError, ( _L( "CUIStore::RemoteMsg: reserve for illegal srcid received") ) );
error = KErrGeneral;
}
if( msg->DstId() != 0 )
{
// Not a broadcast
if( ( msg->DstDevId() != DevId() ) ||
( msg->DstTestId() != 0 ) )
{
__TRACE( KError, ( _L( "CUIStore::RemoteMsg: reserve for illegal dstid received") ) );
error = KErrGeneral;
}
}
resp->AppendId( SETID( (TInt32)DevId(), 0 ) );
resp->AppendId( msg->SrcId() );
resp->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgReserve );
if( error != KErrNone )
{
resp->Append( CStifTFwIfProt::RespParam, CStifTFwIfProt::ERespResult, error );
}
}
break;
case CStifTFwIfProt::EMsgRelease:
{
// Check protocol ids
if( ( msg->SrcDevId() == 0 ) ||
( msg->SrcTestId() == 0 ) ||
( msg->DstTestId() != 0 ) )
{
__TRACE( KError, ( _L( "CUIStore::RemoteMsg: release for illegal srcid or dstid received") ) );
error = KErrGeneral;
}
else if( msg->DstDevId() != DevId() )
{
__TRACE( KError, ( _L( "CUIStore::RemoteMsg: release for illegal dstid received") ) );
error = KErrNotFound;
}
resp->AppendId( msg->DstId() );
resp->AppendId( msg->SrcId() );
resp->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRelease );
if( error != KErrNone )
{
resp->Append( CStifTFwIfProt::RespParam, CStifTFwIfProt::ERespResult, error );
}
}
break;
case CStifTFwIfProt::EMsgRemote:
{
// Check protocol ids
if( ( msg->SrcDevId() == 0 ) ||
( msg->SrcTestId() == 0 ) ||
( msg->DstDevId() == 0 ) )
{
__TRACE( KError, ( _L( "CUIStore::RemoteMsg: remote for illegal srcid or dstid received") ) );
error = KErrGeneral;
}
else
{
__TRACE( KError, ( _L( "CUIStore::RemoteMsg: received remote call") ) );
error = MsgRemote( aContainer, *msg, *resp );
}
if( error != KErrNone )
{
resp->AppendId( msg->DstId() );
resp->AppendId( msg->SrcId() );
resp->Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote );
resp->Append( msg->iCmdDes );
resp->Append( CStifTFwIfProt::RespParam,
CStifTFwIfProt::ERespResult,
error );
}
else
{
sendResp = EFalse;
}
}
break;
case CStifTFwIfProt::EMsgResponse:
default:
__TRACE( KError, ( _L( "CUIStore::RemoteMsg: invalid message")) );
ret = KErrNotSupported;
}
if( ( ret == KErrNone ) && sendResp )
{
aContainer->RemoteReceive( resp->Message() );
}
delete msg;
delete resp;
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: MsgRemote
Description: Remote command
Parameters: const TDesC& aMessage: in:
Return Values: KErrNotSupported
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::MsgRemote( CUIEngineContainer* aContainer,
CStifTFwIfProt& aReq,
CStifTFwIfProt& aResp )
{
TInt ret = KErrNone;
switch( aReq.iCmdType )
{
case CStifTFwIfProt::ECmdRun:
ret = MsgRemoteRun( aContainer, aReq, aResp );
break;
case CStifTFwIfProt::ECmdPause:
case CStifTFwIfProt::ECmdResume:
case CStifTFwIfProt::ECmdCancel:
ret = MsgRemoteTestCtl( aContainer, aReq, aResp );
break;
case CStifTFwIfProt::ECmdRequest:
case CStifTFwIfProt::ECmdRelease:
case CStifTFwIfProt::ECmdSetEvent:
case CStifTFwIfProt::ECmdUnsetEvent:
ret = MsgRemoteEventCtl( aContainer, aReq, aResp );
break;
case CStifTFwIfProt::ECmdSendReceive:
{
ret = MsgRemoteSendReceive( aContainer, aReq, aResp );
break;
}
default:
{
CStifTFwIfProt* resp = NULL;
TRAPD( err,
resp = CStifTFwIfProt::NewL();
resp->CreateL();
);
if( err != KErrNone )
{
delete resp;
return err;
}
resp->SetMsgType( CStifTFwIfProt::EMsgResponse );
resp->SetSrcId( aReq.DstId() );
resp->SetDstId( aReq.SrcId() );
resp->SetRespType( CStifTFwIfProt::EMsgRemote );
// Command type must be set separately,
// because it is unspecified in this case
resp->iCmdType = aReq.iCmdType;
resp->Append( aReq.iCmdDes );
ret = RemotePopup( aContainer, aReq.Message(), resp );
if( ret != KErrNone )
{
delete resp;
}
}
break;
}
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: AtsRemoteRun
Description: Remote run message
Parameters: const TDesC& aMessage: in:
Return Values: KErrNotSupported
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::MsgRemoteRun( CUIEngineContainer* aContainer,
CStifTFwIfProt& aReq,
CStifTFwIfProt& /* aResp */)
{
TInt ret = KErrNone;
TUint16 testid = 0;
if( ( aReq.DstDevId() == 0 ) ||
( aReq.DstTestId() != 0 ) )
{
// Protocol violation
__TRACE( KError, ( _L( "AtsReceive: remote run for illegal dstid received") ) );
return KErrGeneral;
}
if ( aReq.DstDevId() != DevId() )
{
// Not our protocol message
__TRACE( KError, ( _L( "AtsReceive: remote run for illegal dstdevid received") ) );
return KErrNotFound;
}
if( aReq.iModule.Length() == 0 )
{
__TRACE( KError, ( _L("No mandatory test module name given as run parameter") ) );
ret = KErrNotFound;
}
else if( aReq.iTestCaseNumber < 0 )
{
__TRACE( KError, ( _L("No mandatory test case number given as run parameter") ) );
ret = KErrNotFound;
}
testid = 1;
CStifTFwIfProt* resp = NULL;
TRAPD( err,
resp = CStifTFwIfProt::NewL();
resp->CreateL();
);
if( err != KErrNone )
{
delete resp;
return err;
}
CStifTFwIfProt* resp2 = NULL;
TRAP( err,
resp2 = CStifTFwIfProt::NewL();
resp2->CreateL();
);
if( err != KErrNone )
{
delete resp2;
return err;
}
resp->SetMsgType( CStifTFwIfProt::EMsgResponse );
resp->SetSrcId( SETID( (TInt32)DevId(), testid ) );
resp->SetDstId( aReq.SrcId() );
resp->SetRespType( CStifTFwIfProt::EMsgRemote );
resp->SetCmdType( CStifTFwIfProt::ECmdRun );
resp2->SetMsgType( CStifTFwIfProt::EMsgResponse );
resp2->SetSrcId( SETID( (TInt32)DevId(), testid ) );
resp2->SetDstId( aReq.SrcId() );
resp2->SetRespType( CStifTFwIfProt::EMsgRemote );
resp2->SetCmdType( CStifTFwIfProt::ECmdRun );
// Remote run started popup call
ret = RemotePopup( aContainer, aReq.Message(), resp, EPopupPriorityHighest );
if( ret != KErrNone )
{
delete resp;
}
// Remote run result popup call
ret = RemotePopup( aContainer, aReq.Message(), resp2 );
if( ret != KErrNone )
{
delete resp2;
}
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: MsgRemoteTestCtl
Description: Remote test control message
Parameters: const TDesC& aMessage: in:
Return Values: KErrNotSupported
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::MsgRemoteTestCtl( CUIEngineContainer* aContainer,
CStifTFwIfProt& aReq,
CStifTFwIfProt& /*aResp*/ )
{
TInt ret = KErrNone;
if( ( aReq.DstDevId() == 0 ) ||
( aReq.DstTestId() == 0 ) )
{
// Protocol violation
__TRACE( KError, ( _L( "AtsReceive: remote test control for illegal dstid received") ) );
return KErrGeneral;
}
if ( aReq.DstDevId() != DevId() )
{
// Not our protocol message
__TRACE( KError, ( _L( "AtsReceive: remote test control for illegal dstdevid received") ) );
return KErrNotFound;
}
CStifTFwIfProt* resp = NULL;
TRAPD( err,
resp = CStifTFwIfProt::NewL();
resp->CreateL();
);
if( err != KErrNone )
{
delete resp;
return err;
}
resp->SetMsgType( CStifTFwIfProt::EMsgResponse );
resp->SetSrcId( aReq.DstId() );
resp->SetDstId( aReq.SrcId() );
resp->SetRespType( CStifTFwIfProt::EMsgRemote );
resp->SetCmdType( aReq.iCmdType );
ret = RemotePopup( aContainer, aReq.Message(), resp );
if( ret != KErrNone )
{
delete resp;
}
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: MsgRemoteEventCtl
Description: Remote run message
Parameters: const TDesC& aMessage: in:
Return Values: KErrNotSupported
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::MsgRemoteEventCtl( CUIEngineContainer* aContainer,
CStifTFwIfProt& aReq,
CStifTFwIfProt& aResp )
{
if( ( aReq.DstDevId() == 0 ) ||
( aReq.DstTestId() != 0 ) )
{
// Protocol violation
__TRACE( KError, ( _L( "AtsReceive: remote event control for illegal dstid received") ) );
return KErrGeneral;
}
if ( aReq.DstDevId() != DevId() )
{
// Not our protocol message
__TRACE( KError, ( _L( "AtsReceive: remote event control for illegal dstdevid received") ) );
return KErrNotFound;
}
if( aReq.iEventName.Length() == 0 )
{
__TRACE( KError, ( _L("No event name given") ) );
return KErrNotFound;
}
TInt ret = KErrNone;
switch( aReq.iCmdType )
{
case CStifTFwIfProt::ECmdRequest:
{
// Send event active information
CStifTFwIfProt* resp = NULL;
TRAP( ret,
resp = CStifTFwIfProt::NewL();
resp->CreateL(); );
if( ret != KErrNone )
{
delete resp;
return ret;
}
resp->SetMsgType( CStifTFwIfProt::EMsgResponse );
resp->SetSrcId( aReq.DstId() );
resp->SetDstId( aReq.SrcId() );
resp->SetRespType( CStifTFwIfProt::EMsgRemote );
resp->SetCmdType( CStifTFwIfProt::ECmdRequest );
resp->Append( CStifTFwIfProt::EventStatus,
CStifTFwIfProt::EEventSet );
resp->Append( aReq.iEventName );
ret = RemotePopup( aContainer, aReq.Message(), resp, EPopupPriorityNormal );
if( ret != KErrNone )
{
delete resp;
}
aResp.AppendId( aReq.DstId() );
aResp.AppendId( aReq.SrcId() );
aResp.Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote );
aResp.Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdRequest );
if( ret == KErrNone )
{
aResp.Append( CStifTFwIfProt::EventStatus,
CStifTFwIfProt::EEventActive );
aResp.Append( aReq.iEventName );
}
else
{
aResp.Append( CStifTFwIfProt::EventStatus,
CStifTFwIfProt::EEventError );
aResp.Append( aReq.iEventName );
aResp.Append( CStifTFwIfProt::EventStatusParams,
CStifTFwIfProt::EEventResult,
ret );
}
ret = aContainer->RemoteReceive( aResp.Message() );
ret = KErrNone;
}
break;
case CStifTFwIfProt::ECmdSetEvent:
{
// Send event active information
CStifTFwIfProt* resp = NULL;
TRAP( ret,
resp = CStifTFwIfProt::NewL();
resp->CreateL(); );
if( ret != KErrNone )
{
delete resp;
return ret;
}
resp->SetMsgType( CStifTFwIfProt::EMsgResponse );
resp->SetSrcId( aReq.DstId() );
resp->SetDstId( aReq.SrcId() );
resp->SetRespType( CStifTFwIfProt::EMsgRemote );
resp->SetCmdType( CStifTFwIfProt::ECmdSetEvent );
resp->Append( CStifTFwIfProt::EventStatus,
CStifTFwIfProt::EEventSet );
resp->Append( aReq.iEventName );
if ( aReq.iEventType == TEventIf::EState )
{
resp->Append( CStifTFwIfProt::EventStatusParams,
CStifTFwIfProt::EEventType,
CStifTFwIfProt::EventType,
TEventIf::EState );
}
ret = RemotePopup( aContainer, aReq.Message(), resp, EPopupPriorityNormal );
if( ret != KErrNone )
{
delete resp;
}
aResp.AppendId( aReq.DstId() );
aResp.AppendId( aReq.SrcId() );
aResp.Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote );
aResp.Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdSetEvent );
if( ret == KErrNone )
{
aResp.Append( CStifTFwIfProt::EventStatus,
CStifTFwIfProt::EEventSet );
aResp.Append( aReq.iEventName );
if ( aReq.iEventType == TEventIf::EState )
{
aResp.Append( CStifTFwIfProt::EventStatusParams,
CStifTFwIfProt::EEventType,
CStifTFwIfProt::EventType,
TEventIf::EState );
}
}
else
{
aResp.Append( CStifTFwIfProt::EventStatus,
CStifTFwIfProt::EEventError );
aResp.Append( CStifTFwIfProt::EventStatusParams,
CStifTFwIfProt::EEventResult,
ret );
}
ret = aContainer->RemoteReceive( aResp.Message() );
ret = KErrNone;
}
break;
case CStifTFwIfProt::ECmdUnsetEvent:
{
// Send event active information
CStifTFwIfProt* resp = NULL;
TRAP( ret,
resp = CStifTFwIfProt::NewL();
resp->CreateL(); );
if( ret != KErrNone )
{
delete resp;
return ret;
}
resp->SetMsgType( CStifTFwIfProt::EMsgResponse );
resp->SetSrcId( aReq.DstId() );
resp->SetDstId( aReq.SrcId() );
resp->SetRespType( CStifTFwIfProt::EMsgRemote );
resp->SetCmdType( CStifTFwIfProt::ECmdUnsetEvent );
resp->Append( CStifTFwIfProt::EventStatus,
CStifTFwIfProt::EEventUnset );
resp->Append( aReq.iEventName );
ret = RemotePopup( aContainer, aReq.Message(), resp, EPopupPriorityNormal );
if( ret != KErrNone )
{
delete resp;
}
aResp.AppendId( aReq.DstId() );
aResp.AppendId( aReq.SrcId() );
aResp.Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote );
aResp.Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdUnsetEvent );
if( ret == KErrNone )
{
aResp.Append( CStifTFwIfProt::EventStatus,
CStifTFwIfProt::EEventUnset );
aResp.Append( aReq.iEventName );
}
else
{
aResp.Append( CStifTFwIfProt::EventStatus,
CStifTFwIfProt::EEventError );
aResp.Append( CStifTFwIfProt::EventStatusParams,
CStifTFwIfProt::EEventResult,
ret );
}
ret = aContainer->RemoteReceive( aResp.Message() );
ret = KErrNone;
}
break;
case CStifTFwIfProt::ECmdRelease:
{
// Check and delete all pending event popup windows for test case
TInt count = iPopups.Count();
for( TInt i = 0; i<count; i++ )
{
if( ( iPopups[i]->Container() == aContainer ) &&
iPopups[i]->IsEventPopup() )
{
delete iPopups[i];
iPopups.Remove( i );
}
}
aResp.AppendId( aReq.DstId() );
aResp.AppendId( aReq.SrcId() );
aResp.Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote );
aResp.Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdRelease );
aResp.Append( aReq.iEventName );
ret = aContainer->RemoteReceive( aResp.Message() );
ret = KErrNone;
}
break;
default:
return KErrNotSupported;
}
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: MsgRemoteSendReceive
Description: Asynchronous remote sendreceive message
Parameters: CUIEngineContainer* aContainer: in:
CStifTFwIfProt& aReq: in
CStifTFwIfProt& aResp: in
Return Values: KErrNotSupported
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::MsgRemoteSendReceive( CUIEngineContainer* aContainer,
CStifTFwIfProt& aReq,
CStifTFwIfProt& aResp )
{
TInt ret = KErrNone;
// TUint16 testid = 0;
if( ( aReq.DstDevId() == 0 ) ||
( aReq.DstTestId() != 0 ) )
{
// Protocol violation
__TRACE( KError, ( _L( "AtsReceive: remote run for illegal dstid received") ) );
return KErrGeneral;
}
if ( aReq.DstDevId() != DevId() )
{
// Not our protocol message
__TRACE( KError, ( _L( "AtsReceive: remote run for illegal dstdevid received") ) );
return KErrNotFound;
}
// testid = 1;
CStifTFwIfProt* resp = NULL;
TRAPD( err,
resp = CStifTFwIfProt::NewL();
resp->CreateL();
);
if( err != KErrNone )
{
delete resp;
return err;
}
resp->SetMsgType( CStifTFwIfProt::EMsgResponse );
//resp->SetSrcId( SETID( DevId(), testid ) );
resp->SetSrcId( aReq.DstId() );
resp->SetDstId( aReq.SrcId() );
resp->SetRespType( CStifTFwIfProt::EMsgRemote );
resp->SetCmdType( CStifTFwIfProt::ECmdSendReceive );
ret = RemotePopup( aContainer, aReq.Message(), resp );
if( ret != KErrNone )
{
delete resp;
}
aResp.AppendId( aReq.DstId() );
aResp.AppendId( aReq.SrcId() );
aResp.Append( CStifTFwIfProt::MsgType, CStifTFwIfProt::EMsgRemote );
aResp.Append( CStifTFwIfProt::CmdType, CStifTFwIfProt::ECmdSendReceive );
if( ret != KErrNone )
{
aResp.Append( CStifTFwIfProt::RunStatus,
CStifTFwIfProt::ERunError );
aResp.Append( CStifTFwIfProt::RunStatusParams,
CStifTFwIfProt::ERunResult, ret );
}
else
{
aResp.Append( CStifTFwIfProt::RunStatus,
CStifTFwIfProt::ERunStarted );
}
// Send response
aContainer->RemoteReceive( aResp.Message() );
// Response is created, return success
ret = KErrNone;
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: GoingToReboot
Description: Reboot indication handling.
Parameters: CUIEngineContainer* aContainer: in: Container
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::GoingToReboot( CUIEngineContainer* /* aContainer */,
TRequestStatus& aStatus )
{
_LIT( KDateString,"%H%T%S.%C" );
const TInt KTimeFieldLength = 30;
TBuf<KTimeFieldLength> time;
// Store info
CStifLogger* logger = CStifLogger::NewL( KUIStoreDefaultDir,
KUIStoreDefaultRebootFile,
CStifLogger::EData,
CStifLogger::EFile,
ETrue,
EFalse,
EFalse,
EFalse,
EFalse,
ETrue );
CleanupStack::PushL( logger );
TInt count = iStartedTestCases.Count();
for( TInt index=0; index<count; index++ )
{
logger->Log( _L("%S\r\n"), &KUIStoreStartTest );
// First test case info
logger->Log( _L("%S %S\r\n"), &KUIStoreCaseModuleName,
&iStartedTestCases[index]->TestInfo().ModuleName() );
logger->Log( _L("%S %S\r\n"), &KUIStoreTestCaseTitle,
&iStartedTestCases[index]->TestInfo().TestCaseTitle() );
if( iStartedTestCases[index]->TestInfo().TestCaseFile().Length() > 0 )
{
logger->Log( _L("%S %S\r\n"), &KUIStoreTestCaseFile,
&iStartedTestCases[index]->TestInfo().TestCaseFile() );
}
logger->Log( _L("%S %d\r\n"), &KUIStoreTestCaseNum,
iStartedTestCases[index]->TestInfo().TestCaseNum() );
logger->Log( _L("%S %d\r\n"), &KUIStoreCasePriority,
iStartedTestCases[index]->TestInfo().Priority() );
//@js<--remove--> logger->Log( _L("%S %d %d\r\n"), &KUIStoreCaseTimeout,
//@js<--remove--> iStartedTestCases[index]->TestInfo().Timeout().Int64().Low(),
//@js<--remove--> iStartedTestCases[index]->TestInfo().Timeout().Int64().High() );
logger->Log( _L("%S %d %d\r\n"), &KUIStoreCaseTimeout,
I64LOW(iStartedTestCases[index]->TestInfo().Timeout().Int64()),
I64HIGH(iStartedTestCases[index]->TestInfo().Timeout().Int64()));
logger->Log( _L("%S %d\r\n"), &KUIStoreCaseExpectedResult,
iStartedTestCases[index]->TestInfo().ExpectedResult() );
logger->Log( _L("%S %d\r\n"), &KUIStoreCaseStatus,
iStartedTestCases[index]->Status() );
logger->Log( _L("%S %d %d\r\n"), &KUIStoreCaseExecutionResult,
iStartedTestCases[index]->Result().iCaseExecutionResultType,
iStartedTestCases[index]->Result().iCaseExecutionResultCode );
logger->Log( _L("%S %d %S\r\n"), &KUIStoreCaseResult,
iStartedTestCases[index]->Result().iTestResult.iResult,
&iStartedTestCases[index]->Result().iTestResult.iResultDes );
// Start time
iStartedTestCases[index]->Result().iStartTime.FormatL(
time, KDateString );
logger->Log( _L("%S %S\r\n"), &KUIStoreCaseStartTime, &time );
// Start time
iStartedTestCases[index]->Result().iEndTime.FormatL(
time, KDateString );
logger->Log( _L("%S %S\r\n"), &KUIStoreCaseEndTime, &time );
logger->Log( _L("%S\r\n\r\n"), &KUIStoreStartTestEnd );
}
CleanupStack::PopAndDestroy( logger );
// Show popup
TKeyCode key;
iUIStoreIf->PopupMsg( _L("GoingToReboot"),
_L("Press any key to continue"),
KRebootPopupTimeout, key, aStatus );
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: LoadExecutedTestCasesL
Description: Load all executed testcases saved before reboot.
Parameters: None
Return Values: None
Errors/Exceptions: Leaves on error
Status: Draft
-------------------------------------------------------------------------------
*/
void CUIStore::LoadExecutedTestCasesL()
{
TPtrC tmp;
TInt num = 0;
TInt high = 0;
TInt64 interval;
TFullTestResult result;
TInt status = 0;
CStifItemParser* item = NULL;
TInt ret = KErrNone;
CStifParser* parser = NULL;
TRAP( ret,
parser = CStifParser::NewL( KUIStoreDefaultDir,
KUIStoreDefaultRebootFile );
);
if( ret != KErrNone )
{
// reboot file not found
return;
}
CleanupStack::PushL( parser );
__TRACE( KInit, ( _L( "Reboot file is found(%S%S). Reboot testing ongoing..." ), &KUIStoreDefaultDir, &KUIStoreDefaultRebootFile ) );
CTestInfo* testInfo = NULL;
CStifSectionParser* section =
parser->SectionL( KUIStoreStartTest, KUIStoreStartTestEnd );
while( section )
{
CleanupStack::PushL( section );
testInfo = CTestInfo::NewL();
CleanupStack::PushL( testInfo );
// Get module name
// Mandatory, leave if not found
User::LeaveIfError(
section->GetLine( KUIStoreCaseModuleName, tmp, ENoTag ) );
testInfo->SetModuleName( tmp );
// Get test case title
// Mandatory, leave if not found
User::LeaveIfError(
section->GetLine( KUIStoreTestCaseTitle, tmp, ENoTag ) );
testInfo->SetTestCaseTitle( tmp );
// Get test case file
num = section->GetLine( KUIStoreTestCaseFile, tmp, ENoTag );
if( ( num == KErrNone ) &&
( tmp.Length() > 0 ) )
{
// Optional
testInfo->SetTestCaseFile( tmp );
}
else
{
testInfo->SetTestCaseFile( KNullDesC );
}
// Get test case number
item = section->GetItemLineL( KUIStoreTestCaseNum );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetInt( KUIStoreTestCaseNum, num ));
testInfo->SetTestCaseNumber( num );
CleanupStack::PopAndDestroy( item );
// Get test case priority
item = section->GetItemLineL( KUIStoreCasePriority );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetInt( KUIStoreCasePriority, num ));
testInfo->SetPriority( num );
CleanupStack::PopAndDestroy( item );
// Get test case timeout
item = section->GetItemLineL( KUIStoreCaseTimeout );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetInt( KUIStoreCaseTimeout, num ));
User::LeaveIfError( item->GetNextInt( high ));
//interval.Set( high, num );
interval = MAKE_TINT64( high, num );
TTimeIntervalMicroSeconds timeout( interval );
testInfo->SetTimeout( timeout );
CleanupStack::PopAndDestroy( item );
// Get test case status
item = section->GetItemLineL( KUIStoreCaseStatus );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetInt( KUIStoreCaseStatus, status ));
CleanupStack::PopAndDestroy( item );
// Get test case execution result
item = section->GetItemLineL( KUIStoreCaseExecutionResult );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetInt( KUIStoreCaseExecutionResult, num ));
result.iCaseExecutionResultType = ( TFullTestResult::TCaseExecutionResult) num;
// Mandatory, leave if not found
User::LeaveIfError( item->GetNextInt( result.iCaseExecutionResultCode ));
CleanupStack::PopAndDestroy( item );
// Get test case result
item = section->GetItemLineL( KUIStoreCaseResult );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetInt( KUIStoreCaseResult,
result.iTestResult.iResult ));
// Not mandatory
TBool first = ETrue;
result.iTestResult.iResultDes.Zero();
ret = item->GetNextString( tmp );
while( ret == KErrNone )
{
if( result.iTestResult.iResultDes.Length() + tmp.Length() + 1 > result.iTestResult.iResultDes.MaxLength() )
{
User::Leave( KErrGeneral );
}
if(!first)
result.iTestResult.iResultDes.Append(_L(" "));
result.iTestResult.iResultDes.Append( tmp );
first = EFalse;
ret = item->GetNextString( tmp );
}
/*
ret = item->GetNextString( tmp );
if( ret == KErrNone )
{
if( tmp.Length() > result.iTestResult.iResultDes.MaxLength() )
{
User::Leave( KErrGeneral );
}
result.iTestResult.iResultDes.Copy( tmp );
}
*/
CleanupStack::PopAndDestroy( item );
// Get test start time
item = section->GetItemLineL( KUIStoreCaseStartTime );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetString( KUIStoreCaseStartTime, tmp ));
result.iStartTime.Set( tmp );
CleanupStack::PopAndDestroy( item );
// Get test end time
item = section->GetItemLineL( KUIStoreCaseEndTime );
CleanupStack::PushL( item );
// Mandatory, leave if not found
User::LeaveIfError( item->GetString( KUIStoreCaseEndTime, tmp ));
result.iEndTime.Set( tmp );
CleanupStack::PopAndDestroy( item );
if( status != CUIStoreIf::EStatusRunning )
{
// Add executed test cases to list
CStartedTestCase* startedCase =
new( ELeave )CStartedTestCase( testInfo, result, status );
User::LeaveIfError( iStartedTestCases.Append( startedCase ) );
CleanupStack::Pop( testInfo );
// Fill data with test case info and send to test engine
TTestInfo *info = new (ELeave) TTestInfo;
CleanupStack::PushL(info);
info->iModuleName.Copy(testInfo->ModuleName());
info->iConfig.Copy(testInfo->TestCaseFile());
info->iTestCaseInfo.iCaseNumber = testInfo->TestCaseNum();
info->iTestCaseInfo.iTitle.Copy(testInfo->TestCaseTitle());
info->iTestCaseInfo.iTimeout = testInfo->Timeout();
info->iTestCaseInfo.iPriority = testInfo->Priority();
iUIEngine->TestEngine().AddTestCaseResultToTestReport(*info, result, KErrNone);
CleanupStack::PopAndDestroy(info);
}
else
{
// Restart testcase that was running when reset was done
CUIEngineContainer* container = NULL;
User::LeaveIfError(
iUIEngine->StartTestCase( container, *testInfo ) );
CStartedTestCase* testCase = NULL;
TRAPD( retVal,
testCase = CStartedTestCase::NewL( *testInfo, *container );
);
if( retVal != KErrNone )
{
iUIEngine->AbortStartedTestCase( container );
User::Leave( retVal );
}
retVal = iStartedTestCases.Append( testCase );
if( retVal != KErrNone )
{
iUIEngine->AbortStartedTestCase( container );
delete testCase;
User::Leave( retVal );
}
CleanupStack::PopAndDestroy( testInfo );
}
CleanupStack::PopAndDestroy( section );
section =
parser->NextSectionL( KUIStoreStartTest, KUIStoreStartTestEnd );
}
CleanupStack::PopAndDestroy( parser );
// Delete file
RFs rf;
TInt retVal = rf.Connect();
if( retVal != KErrNone )
{
User::Leave( retVal );
}
TFileName file( KUIStoreDefaultDir );
file.Append( KUIStoreDefaultRebootFile );
rf.Delete( file );
rf.Close();
return;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: FindByContainer
Description: Find test case with UIEngine Container pointer.
Parameters: CUIEngineContainer* const aContainer: in: Execution container
CStartedTestCase*& aTestCase: out: Testcase info
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::FindByContainer( CUIEngineContainer* const aContainer,
CStartedTestCase*& aTestCase )
{
TInt count = iStartedTestCases.Count();
TInt index = 0;
for( ; index < count; index++ )
{
if( ( iStartedTestCases[index]->Status() &
CUIStoreIf::EStatusRunning ) &&
( &iStartedTestCases[index]->UIEngineContainer() ==
aContainer ) )
{
aTestCase = iStartedTestCases[index];
return KErrNone;
}
}
return KErrNotFound;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: UpdateCases
Description: Refreshs iTestCases array ie. fetches test cases from
test framework
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::UpdateCases()
{
if( iUpdateNeeded )
{
TInt handle = iUIStoreIf->PopupMsg(
_L("Updating"), _L("Test cases"), 60 );
iTestCases.ResetAndDestroy();
TRAPD( ret,
ret = iUIEngine->GetTestCasesL( iTestCases );
);
iUpdateNeeded = EFalse;
// Close popup
iUIStoreIf->Close( handle );
if( iTestCases.Count() == 0 )
{
iUIStoreIf->PopupMsg( _L("No test cases found"),
_L("e.g. check TestEngine log"),
3 );
}
return ret;
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: CheckIniL
Description: Check ini file
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CUIStore::CheckIniL( TFileName& aIni )
{
RFs fs;
User::LeaveIfError( fs.Connect() );
RFile file;
TInt err = KErrNone;
TErrorNotification error;
error.iModule.Copy( KUIStore );
TStifUtil::CorrectFilePathL( aIni );
if ( aIni.Length() != 0 )
{
err = file.Open ( fs, aIni, EFileRead );
if ( err == KErrNone )
{
// Use the file given as command line parameter
iUIStoreIf->PopupMsg( _L("Using given ini-file"),
KNullDesC, 0 );
file.Close();
fs.Close();
return;
}
else
{
error.iText.Copy( _L("Can't open given ini-file") );
iUIStoreIf->Error( error );
aIni.Zero();
}
}
// Try to locate default ini file from every drive
TDriveList drivelist;
User::LeaveIfError( fs.DriveList(drivelist) );
// A TDriveList (the list of available drives), is an array of
// 26 bytes. Each byte with a non zero value signifies that the
// corresponding drive is available.
TInt driveNumber;
TChar driveLetter;
for( driveNumber=EDriveA; driveNumber<=EDriveZ; driveNumber++ )
{
if( !drivelist[driveNumber] )
{
// If drive-list entry is zero, drive is not available
continue;
}
User::LeaveIfError(
fs.DriveToChar( driveNumber, driveLetter ));
aIni.Zero();
aIni.Append( driveLetter );
aIni.Append( _L(":") );
aIni.Append( KDefaultIni );
// Try to open
err = file.Open ( fs, aIni, EFileRead );
if ( err == KErrNone )
{
// Use default file
file.Close();
TFileName info( _L("Using default ini-file ") );
if( info.MaxLength()-info.Length() > aIni.Length() )
{
// Show also filename if fits to descriptor
info.Append( aIni );
}
iUIStoreIf->PopupMsg( info, KNullDesC, 0 );
break;
}
}
if( err != KErrNone )
{
iUIStoreIf->PopupMsg( _L("Starting without ini-file"),
KNullDesC, 0);
aIni.Zero();
}
fs.Close();
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: ParseTestSetName
Description: Parses test set name from test set filename.
Parameters: const TDesC& aSetFileName: in: Test set filename
TPtrC& aSetName: out: testset name
TFileName& aFileName: in: filenamebuffer
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::ParseTestSetName( const TDesC& aSetFileName,
TPtrC& aSetName,
TFileName& aFileName )
{
if( aSetFileName.Length() > KMaxFileName )
{
return KErrArgument;
}
aFileName.Copy( aSetFileName );
TParsePtr p( aFileName );
aSetName.Set( p.NameAndExt() ); // gives test set name without path
if( aSetName.Length() > KMaxName )
{
return KErrArgument;
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: RemotePopup
Description: Do remote message popup
Parameters: const TDesC& aReq: in: request
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::RemotePopup( CUIEngineContainer* aContainer,
const TDesC& aMsg,
CStifTFwIfProt* aResp,
TPopupPriority aPopupPriority )
{
TInt ret = KErrNone;
CUIStorePopup* popup = NULL;
TRAP( ret, popup = CUIStorePopup::NewL( this, aContainer, aResp, aPopupPriority, aMsg ); );
if( ret != KErrNone )
{
return ret;
}
ret = iPopups.Append( popup );
if( ret != KErrNone )
{
delete popup;
return ret;
}
// We'll put new popup to the top if there are no popups active or if
// currently active popup has lower priority than the new one
if( !iPopupActive || iActivePopupPriority > popup->GetPriority() )
{
SetRemotePopupFromQueue();
}
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: SetRemotePopupFromQueue
Description: Prints the highest priority popup to the UI from the popup
queue
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft @js
-------------------------------------------------------------------------------
*/
void CUIStore::SetRemotePopupFromQueue()
{
CUIStorePopup* popup = NULL;
if(iPopups.Count() > 0 )
{
TInt highest = 0;
// Let's get the highest priority popup and print it to the UI
for( TInt x=0; x<iPopups.Count(); x++)
{
if( iPopups[x]->GetPriority() < iPopups[highest]->GetPriority() )
{
highest = x;
}
}
popup = iPopups[highest];
if( popup == NULL )
{
// Some weird error
iPopupActive = EFalse;
return;
}
// Change the active popup priority
iActivePopupPriority = popup->GetPriority();
// Create proper popup
if( popup->GetPriority() == EPopupPriorityHighest )
{
popup->Start( popup->GetMessage().Right( popup->GetMessage().Length() - KRcpHeaderLen ),
_L("Press any key to send 'remote run started' message"));
}
else if( popup->GetPriority() == EPopupPriorityNormal )
{
popup->Start( popup->GetMessage().Right( popup->GetMessage().Length() - KRcpHeaderLen ),
_L("Press any key to set event") );
}
else if( popup->GetPriority() == EPopupPriorityLow )
{
popup->Start( popup->GetMessage().Right( popup->GetMessage().Length() - KRcpHeaderLen ),
_L("Press 1-9 to return negative error value, a to switch to another remote run result popup, or any other key to return 0") );
}
iPopupActive = ETrue;
}
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: ShuffleRemoteRunResultPopups
Description: Shuffle remote run result popups
Parameters: CUIStorePopup* aPopup (currently active popup)
Return Values: None
Errors/Exceptions: None
Status: Draft @js
-------------------------------------------------------------------------------
*/
void CUIStore::ShuffleRemoteRunResultPopups( CUIStorePopup* aPopup )
{
TInt nextPopupId = -1;
for( TInt x=0; x<iPopups.Count(); x++)
{
// Lets find the next remote run result priority popup
if( iPopups[x]->GetPriority() == EPopupPriorityLow && iPopups[x] != aPopup )
{
nextPopupId = x;
break;
}
}
if( nextPopupId == -1 )
{
// We'll print error message popup, because there weren't any other remote run
// result popups active
iUIStoreIf->PopupMsg(
_L("Error! There weren't any other remote run result popups active."),
_L(""),
5 );
User::After( 5000000 );
iPopups.Append( aPopup );
SetRemotePopupFromQueue();
return;
}
// We'll add the popup to the end of the array
TInt ret = iPopups.Append( aPopup );
if( ret != KErrNone )
{
delete aPopup;
return;
}
// Print the next popup from queue
SetRemotePopupFromQueue();
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: RemotePopup
Description: Do remote message popup
Parameters: const TDesC& aReq: in: request
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CUIStore::RemotePopupComplete( CUIStorePopup* aPopup,
TInt aError,
CUIEngineContainer* aContainer,
CStifTFwIfProt* aResp,
TKeyCode aKeyCode )
{
TInt ret = KErrNone;
TInt index = iPopups.Find( aPopup );
if( index < 0 )
{
User::Panic( KUIStore, KErrGeneral );
}
iPopups.Remove( index );
iPopupActive = EFalse;
iActivePopupPriority = EPopupPriorityLow;
if( aError != KErrNone )
{
ret = aError;
}
else
{
TChar c( aKeyCode );
if( c.IsDigit() )
{
// Solve return value
ret = -( aKeyCode - '0' );
}
else
{
ret = KErrNone;
}
}
// If aResp is given, send it
if( aResp )
{
switch( aResp->iCmdType )
{
case CStifTFwIfProt::ECmdRun:
{
TChar response( aKeyCode );
RDebug::Print(_L("CUIStore::RemotePopupComplete: user pressed key %c"), (char)response);
if( aPopup->GetPriority() == EPopupPriorityHighest )
{
// User has given response to remote run started- popup
aResp->Append( CStifTFwIfProt::RunStatus,
CStifTFwIfProt::ERunStarted );
}
else if( aPopup->GetPriority() == EPopupPriorityLow && response=='a' )
{
// User wants to change current remote run result popup to other
// remote run result popup.
ShuffleRemoteRunResultPopups( aPopup );
return KErrNone;
}
else
{
// The test case result was given
aResp->Append( CStifTFwIfProt::RunStatus,
CStifTFwIfProt::ERunReady );
if( ret != KErrNone )
{
aResp->Append( CStifTFwIfProt::RunStatusParams,
CStifTFwIfProt::ERunResult, ret );
}
}
break;
}
case CStifTFwIfProt::ECmdSendReceive:
{
aResp->Append( CStifTFwIfProt::RunStatus,
CStifTFwIfProt::ERunReady );
if( ret != KErrNone )
{
aResp->Append( CStifTFwIfProt::RunStatusParams,
CStifTFwIfProt::ERunResult, ret );
}
break;
}
case CStifTFwIfProt::ECmdPause:
case CStifTFwIfProt::ECmdResume:
case CStifTFwIfProt::ECmdCancel:
case CStifTFwIfProt::ECmdRequest:
case CStifTFwIfProt::ECmdRelease:
default:
if( ret != KErrNone )
{
aResp->Append( CStifTFwIfProt::RespParam,
CStifTFwIfProt::ERespResult,
ret );
}
break;
}
ret = aContainer->RemoteReceive( aResp->Message() );
}
delete aPopup;
SetRemotePopupFromQueue();
return ret;
}
/*
-------------------------------------------------------------------------------
Class: CUIStore
Method: ReadFiltersL
Description: Reads filters from test framework initialization file.
Parameters: RPointerArray<TDesC>& aFilters: array to be filled
Return Values: None
Errors/Exceptions:
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C void CUIStore::ReadFiltersL(RPointerArray<TDesC>& aFilters)
{
// Clean array
aFilters.ResetAndDestroy();
// Locate file
_LIT(KFilterSectionStart, "[Filters]");
_LIT(KFilterSectionEnd, "[End_Filters]");
_LIT(KFilterDefinition, "filter=");
// Parse initialization file
TInt err = KErrNone;
CStifParser* parser;
RDebug::Print(_L("STIF: Try to read filters from [%S]"), &iTestFrameworkIni);
parser = CStifParser::NewL(KNullDesC, iTestFrameworkIni);
CleanupStack::PushL(parser);
// Parser created (file exists), create section parser
CStifSectionParser* section;
section = parser->SectionL(KFilterSectionStart, KFilterSectionEnd);
if(section)
{
CleanupStack::PushL(section);
// Get item lines
CStifItemParser* item = section->GetItemLineL(KFilterDefinition, ENoTag);
TPtrC ptr;
while(item)
{
CleanupStack::PushL(item);
// Read filter value
err = item->GetString(KNullDesC, ptr);
if(err == KErrNone)
{
HBufC* filter = ptr.AllocLC();
User::LeaveIfError(aFilters.Append(filter));
CleanupStack::Pop();
}
CleanupStack::PopAndDestroy(item);
item = NULL;
item = section->GetNextItemLineL(KFilterDefinition, ENoTag);
}
CleanupStack::PopAndDestroy(section);
}
// Clean
CleanupStack::PopAndDestroy(parser);
// If there are some filters added, first filter has to be "No filter"
if(aFilters.Count() > 0)
{
RDebug::Print(_L("STIF: Filters loaded"));
_LIT(KNoFilter, "No filter");
HBufC* name = KNoFilter().AllocLC();
User::LeaveIfError(aFilters.Insert(name, 0));
CleanupStack::Pop(name);
}
}
/*
-------------------------------------------------------------------------------
DESCRIPTION
This module contains implementation of CUIStoreIf class member functions.
-------------------------------------------------------------------------------
*/
// ================= MEMBER FUNCTIONS =========================================
/*
-------------------------------------------------------------------------------
Class: CUIStoreIf
Method: ConstructL
Description: Second phase constructor.
Parameters: None
Return Values: None
Errors/Exceptions: Leaves if..
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C void CUIStoreIf::ConstructL( )
{
iUIStore = CUIStore::NewL( this );
}
/*
-------------------------------------------------------------------------------
Class: CUIStoreIf
Method: CUIStoreIf
Description: Constructor.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C CUIStoreIf::CUIStoreIf( )
{
}
/*
-------------------------------------------------------------------------------
Class: CUIStoreIf
Method: ~CUIStoreIf
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C CUIStoreIf::~CUIStoreIf()
{
delete iUIStore;
iUIStore = NULL;
}
/*
-------------------------------------------------------------------------------
Class: CUIStoreIf
Method: UIStore
Description: Returns reference to CUIStore object, which handles test
cases and test modules.
Parameters: None
Return Values: CUIStore reference
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
EXPORT_C CUIStore& CUIStoreIf::UIStore()
{
__ASSERT_ALWAYS( iUIStore, User::Panic( KUIStoreIf, KErrNotFound ) );
return *iUIStore;
}
/*
-------------------------------------------------------------------------------
DESCRIPTION
This module contains implementation of CTestSetInfo class member functions.
-------------------------------------------------------------------------------
*/
// ================= MEMBER FUNCTIONS =========================================
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: NewL
Description: Construct the CTestSetInfo class
Parameters: None
Return Values: CTestSetInfo* New object
Errors/Exceptions: Leaves if memory allocation fails or
ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetInfo* CTestSetInfo::NewL( const TDesC& aName )
{
CTestSetInfo* self = new ( ELeave ) CTestSetInfo();
CleanupStack::PushL( self );
self->ConstructL( aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: ConstructL
Description: Second phase constructor.
Parameters: None
Return Values: None
Errors/Exceptions: Leaves if..
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetInfo::ConstructL( const TDesC& aName )
{
iName = aName.AllocL();
}
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: CTestSetInfo
Description: Constructor.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetInfo::CTestSetInfo()
{
iLastStartedCaseIndex = 0;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: ~CTestSetInfo
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetInfo::~CTestSetInfo()
{
iTestCases.ResetAndDestroy();
iTestCaseRefs.Reset();
iTestCases.Close();
iTestCaseRefs.Close();
delete iName;
iName = NULL;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: AddTestCase
Description: Add test case to test set.
Parameters: const CTestInfo& aTestInfo: in: test info
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CTestSetInfo::AddTestCase( const CTestInfo& aTestInfo )
{
CTestInfo* testInfo = NULL;
TRAPD( err,
testInfo = CTestInfo::NewL();
testInfo->CopyL( aTestInfo );
);
if( err != KErrNone )
{
return err;
}
if( iTestCaseRefs.Append( *testInfo ) != KErrNone )
{
delete testInfo;
return KErrNoMemory;
}
if( iTestCases.Append( testInfo ) != KErrNone )
{
iTestCaseRefs.Remove( iTestCaseRefs.Count()-1 );
delete testInfo;
return KErrNoMemory;
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: InsertTestCase
Description: Insert test case to test set.
Parameters: const CTestInfo& aTestInfo: in: test info
TInt aPos: in: position to add
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CTestSetInfo::InsertTestCase( const CTestInfo& aTestInfo, TInt aPos )
{
if( ( aPos < 0 ) ||
( aPos >= iTestCases.Count() ) )
{
return KErrArgument;
}
CTestInfo* testInfo = NULL;
TRAPD( err,
testInfo = CTestInfo::NewL();
testInfo->CopyL( aTestInfo );
);
if( err != KErrNone )
{
return err;
}
if( iTestCaseRefs.Insert( *testInfo, aPos ) != KErrNone )
{
delete testInfo;
return KErrNoMemory;
}
if( iTestCases.Insert( testInfo, aPos ) != KErrNone )
{
iTestCaseRefs.Remove( aPos );
delete testInfo;
return KErrNoMemory;
}
return err;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: RemoveTestCase
Description: Remove test case from test set.
Parameters: const CTestInfo& aTestInfo: in: test info
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CTestSetInfo::RemoveTestCase( const CTestInfo& aTestInfo )
{
TInt count = iTestCases.Count();
for( TInt i=0; i<count; i++ )
{
if( aTestInfo == *iTestCases[i] )
{
CTestInfo* testInfo = iTestCases[i];
iTestCases.Remove( i );
iTestCaseRefs.Remove( i );
delete testInfo;
return KErrNone;
}
}
return KErrNotFound;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: CopyL
Description: Remove test case from test set.
Parameters: const CTestInfo& aTestInfo: in: test info
Return Values: Symbian OS error code
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetInfo::CopyL( const CTestSetInfo& aTestSetInfo )
{
iTestCaseRefs.Reset();
iTestCases.ResetAndDestroy();
TInt count = aTestSetInfo.TestCases().Count();
for( TInt i=0; i<count; i++ )
{
User::LeaveIfError( AddTestCase( aTestSetInfo.TestCases()[i] ) );
}
delete iName;
iName = 0;
iName = aTestSetInfo.Name().AllocL();
iLastStartedCaseIndex = aTestSetInfo.iLastStartedCaseIndex;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: SetLastStartedCaseIndex
Description: Sets the info which test case has been started lately.
Parameters: TInt aCaseStarted: index of started test case
Return Values: None
Errors/Exceptions: None
Status: Approved
-------------------------------------------------------------------------------
*/
void CTestSetInfo::SetLastStartedCaseIndex(TUint aLastStartedCaseIndex)
{
iLastStartedCaseIndex = aLastStartedCaseIndex;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetInfo
Method: GetLastStartedCaseIndex
Description: Gets the info which test case has been started lately.
Parameters: None
Return Values: TInt: index of lately started test case
Errors/Exceptions: None
Status: Approved
-------------------------------------------------------------------------------
*/
TUint CTestSetInfo::GetLastStartedCaseIndex(void)
{
return iLastStartedCaseIndex;
}
// ================= OTHER EXPORTED FUNCTIONS =================================
// End of File