diff -r bbd31066657e -r 8bb370ba6d1d testexecfw/stf/stfui/uiengine/src/UIStore.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/testexecfw/stf/stfui/uiengine/src/UIStore.cpp Fri Apr 09 10:46:28 2010 +0800 @@ -0,0 +1,4867 @@ +/* +* 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 +#include +#include +#include +#include + +#include + +#include "Logging.h" +#include +#include +#include +#include "UIStorePopup.h" +#include + + +// 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& 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& 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& 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& 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& aTestModules: out: modules array + + Return Values: Symbian OS error code + + Errors/Exceptions: None + + Status: Draft + +------------------------------------------------------------------------------- +*/ +EXPORT_C TInt CUIStore::Modules( RRefArray& 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& 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& 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 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& 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& 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& aSetInfos: out: list of test sets + + Return Values: Symbian OS error code + + Errors/Exceptions: None + + Status: Draft + +------------------------------------------------------------------------------- +*/ +EXPORT_C TInt CUIStore::TestSets( RRefArray& aSetInfos ) + { + + TInt count = iTestSets.Count(); + for( TInt i=0; i& 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& 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& 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& 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;ioperator[](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; iName() == 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; iIsRunning( 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& 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& aTestCases ) + { + + RRefArray testCaseFiles; + RRefArray 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; cIndStatus(); + 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; iContainer() == 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; iContainer() == 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 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; indexLog( _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; xGetPriority() < 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; xGetPriority() == 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& aFilters: array to be filled + + Return Values: None + + Errors/Exceptions: + + Status: Draft + +------------------------------------------------------------------------------- +*/ +EXPORT_C void CUIStore::ReadFiltersL(RPointerArray& 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