/*
* 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
* CMenu-derived classes.
*
*/
// INCLUDE FILES
#include <e32base.h>
#include <e32cons.h>
#include <e32svr.h>
#include <f32file.h>
#include <stifinternal/UIEngineContainer.h>
#include "ConsoleUI.h"
#include "ConsoleMenus.h"
// EXTERNAL DATA STRUCTURES
// EXTERNAL FUNCTION PROTOTYPES
// CONSTANTS
// MACROS
// LOCAL CONSTANTS AND MACROS
// MODULE DATA STRUCTURES
// LOCAL FUNCTION PROTOTYPES
LOCAL_C void LimitedAppend( TDes& aOriginal, const TDesC& aAppend);
// FORWARD DECLARATIONS
// ==================== LOCAL FUNCTIONS =======================================
LOCAL_C void LimitedAppend( TDes& aOriginal, const TDesC& aAppend)
{
TInt spaceLeft = aOriginal.MaxLength() - aOriginal.Length();
if (spaceLeft > aAppend.Length())
{
aOriginal.Append ( aAppend );
}
else
{
aOriginal.Append ( aAppend.Left ( spaceLeft ) );
}
}
// None
// ================= MEMBER FUNCTIONS =========================================
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName
)
{
CMenu* self = new ( ELeave ) CMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
const TDesC& aHeader :in: Text containing STIF version info
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
const TDesC& aHeader
)
{
// Store the parameters
iMain = aConsole;
iConsole = aConsole->GetConsole();
iParent = aParent;
iName = aName;
iHeader = aHeader;
// Get display size
const TInt KOverHead = 5;
//iSize = iConsole->ScreenSize();
iConsole->ScreenSize(iSize);
iScreenSize = iSize.iHeight - KOverHead; // Size available for menus
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: CMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu::CMenu()
{
iDirection = 1;
iPrevPos = -1; // Invalid starting value
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: ~CMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu::~CMenu()
{
iItems.ResetAndDestroy();
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: TimerUpdate
Description: TimerUpdate
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMenu::TimerUpdate()
{
RRefArray<TDesC> texts;
User::LeaveIfError( ItemTexts( texts ) );
TInt count = texts.Count();
// If list is empty, do not scroll.
if ( count < 1 )
{
texts.Close();
return;
}
// Recalculate visible part of menu
Recalculate( count );
// If menu selection is updated, then restart scrolling
if (iPrevPos != iFirst + iPosOnScreen)
{
iPrevPos = iFirst + iPosOnScreen;
iStart = 0;
iDirection = 1;
}
// If menu item have not been changed after last timer, then
// start scrolling
const TDesC& name = texts[ iFirst + iPosOnScreen ];
if ( name.Length() > ( iSize.iWidth - KMenuOverhead ) )
{
//TInt y = iConsole->WhereY();
//TInt x = iConsole->WhereX();
TPoint cp;
iConsole->CursorPos(cp);
TInt y = cp.iY;
TInt x = cp.iX;
TBuf<80> iTmp;
iStart = iStart + iDirection;
// "Right end"
if ( iStart + iSize.iWidth > name.Length() + KMenuOverhead )
{
iStart--;
iDirection = -1;
}
// "Left end"
if ( iStart == -1 )
{
iStart++;
iDirection = 1;
}
if( iStart > name.Length() )
{
iStart = 0;
}
iTmp=_L(" *");
LimitedAppend( iTmp, name.Mid ( iStart ) );
//iConsole->SetPos( 0, iPosOnScreen+1);
TPoint p(0, iPosOnScreen+1);
iConsole->SetCursorPosAbs( p);
//iConsole->Printf ( iTmp.Left( iSize.iWidth -2 ) );
iConsole->Write ( iTmp.Left( iSize.iWidth -2 ) );
//iConsole->SetPos(x,y);
p.SetXY(x,y);
iConsole->SetCursorPosAbs(p);
}
texts.Close();
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: AppendBefore
Description: Append text before line.
Parameters: TInt aLine: in: line number
TDes& aLine: in: line text
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMenu::AppendBefore( TInt aLineNum, TDes& aLine )
{
if( ( aLine.MaxLength() - aLine.Length() ) < 2 )
{
return;
}
// If printing active line, print the marker
if ( aLineNum == iPosOnScreen + iFirst )
{
aLine.Append( _L(" *") );
}
else
{
aLine.Append( _L(" ") );
}
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: PrintMenuL
Description: Prints the menu
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMenu::PrintMenuL( TUpdateType aType )
{
iUpdateType = aType;
TBuf<KMaxLineLength> line;
// Clear display
iConsole->ClearScreen();
//Print STIF version information, only when defined (i.e. in main menu)
if(iHeader != _L(""))
Print(iHeader);
// Print menu title
Print( Name() );
RRefArray<TDesC> texts;
User::LeaveIfError( ItemTexts( texts ) );
// Recalculate visible part of menu
Recalculate( texts.Count() );
// Print items
for ( TInt i = iFirst; i <= iLast; i++ )
{
line.Zero();
// Append text before line
AppendBefore( i, line );
// Get the menu line
LimitedAppend ( line, texts[i] );
// Print the line
Print(line);
}
texts.Close();
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: SelectL
Description: Process keypresses in menu. Either updates position in
menu or returns new menu.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
switch ( (TInt) aSelection )
{
// Exit
case EKeyEscape:
aContinue = EFalse;
return this;
// SelectL item
case EKeyEnter:
case EKeyRightArrow:
return iItems[iPosOnScreen];
// Going back
case EKeyLeftArrow:
return iParent;
// Go down
case EKeyDownArrow:
{
if ( iFirst + iPosOnScreen == iItemCount - 1 )
{
// If end of the list, go to beginning
iPosOnScreen = 0;
iFirst = 0;
iLast = iScreenSize;
if ( iLast > iItemCount - 1 )
{
iLast = iItemCount - 1;
}
}
else
{
if ( iPosOnScreen == iScreenSize )
{
iLast++;
iFirst++;
}
else
{
// Going down "in-screen", no need to update items
iPosOnScreen++;
}
}
break;
}
// Go Up
case EKeyUpArrow:
{
if ( iFirst + iPosOnScreen == 0 )
{
// If in the beginning of the list
if(iItemCount > 0)
{
iLast = iItemCount - 1;
iFirst = iLast - iScreenSize;
if ( iFirst < 0 )
{
iFirst = 0;
}
iPosOnScreen = iLast - iFirst;
}
}
else if ( iPosOnScreen == 0 )
{
iLast--;
iFirst--;
}
else
{
iPosOnScreen--;
}
break;
}
// Additional keys
case EKeyHome:
case '3':
iPosOnScreen = 0;
iFirst = 0;
iLast = iScreenSize;
if ( iLast > iItemCount - 1 )
{
iLast = iItemCount - 1;
}
break;
case EKeyEnd:
case '9':
iLast = iItemCount - 1;
iFirst = iLast - iScreenSize;
if ( iFirst < 0 )
{
iFirst = 0;
}
iPosOnScreen = iLast - iFirst;
break;
case EKeyPageUp:
case '1':
iFirst = iFirst - iScreenSize;
iLast = iLast - iScreenSize;
if ( iFirst < 0 )
{
iFirst = 0;
iPosOnScreen = 0;
iLast = iScreenSize;
if ( iLast > iItemCount - 1 )
{
iLast = iItemCount - 1;
}
}
break;
case EKeyPageDown:
case '7':
iFirst = iFirst + iScreenSize;
iLast = iLast + iScreenSize;
// Going too far
if ( iLast > iItemCount - 1 )
{
iLast = iItemCount - 1;
iFirst = iLast - iScreenSize;
if ( iFirst < 0 )
{
iFirst = 0;
}
}
iPosOnScreen = iLast - iFirst;
break;
default: // Bypass the keypress
break;
}
// Continue normally and keep in the same menu
aContinue = ETrue;
return this;
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
TInt count = iItems.Count();
for( TInt i=0; i<count; i++ )
{
if( aArray.Append( iItems[i]->Name() ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: SetParent
Description: Sets menu parent menu.
Parameters: CMenu* aMenu :in: Menu parent
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMenu::SetParent ( CMenu* aMenu )
{
iParent = aMenu;
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: Print
Description: Prints one line text and changes to next line. If line is
too long, overhead is not printed..
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMenu::Print( const TDesC& aPrint )
{
//iConsole->Printf ( aPrint.Left( iSize.iWidth - KMenuOverhead ) );
iConsole->Write ( aPrint.Left( iSize.iWidth - KMenuOverhead ) );
//iConsole->Printf(_L("\n"));
iConsole->Write(_L("\r\n"));
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: PrintMulti
Description: Prints text. If line is too long, it will be continued to
following lines.
Parameters: const TDesC& aPrint :in: Text to print
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMenu::PrintMulti( const TDesC& aPrint )
{
// Get current line
const TInt KMenuOverHead = 2;
//TInt y = iConsole->WhereY();
TPoint cp;
iConsole->CursorPos(cp);
TInt y = cp.iY;
const TInt KLineLen =iSize.iWidth -4;
TBuf<KMaxLineLength+1> oneLine;
// Loop through the line
for (TInt i = 0; i < aPrint.Length(); i++)
{
oneLine.Append( aPrint[i] );
// Print one line
if (oneLine.Length() == KLineLen )
{
oneLine.Append (_L("\r\n"));
//iConsole->Printf(oneLine);
iConsole->Write(oneLine);
oneLine=_L("");
y++;
}
// Prevent display scrolling
if ( y == iScreenSize + KMenuOverHead )
{
oneLine=_L("");
break;
}
}
// Print last part if required
if ( oneLine.Length() != 0 )
{
oneLine.Append (_L("\r\n"));
//iConsole->Printf(oneLine);
iConsole->Write(oneLine);
}
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: AddItem
Description: Add new item to menu
Parameters: CMenu* aMenu :in: Menu to be added
Return Values: None
Errors/Exceptions: Leaves if can't add item to menu
Status: Draft
-------------------------------------------------------------------------------
*/
void CMenu::AddItemL( CMenu* aMenu )
{
User::LeaveIfError ( iItems.Append (aMenu) );
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: Name
Description: Returns menu name
Parameters: None
Return Values: const TDesC& Menu name
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
const TDesC& CMenu::Name( ) const
{
return iName;
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: MapKeyCode
Description: Maps numeric keycodes to proper TKeyCode values
Parameters: TKeyCode
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMenu::MapKeyCode(TKeyCode &aSelection)
{
TInt asciiCode = (TInt) aSelection;
// Handling numeric keys 2,4,6 and 8
if(asciiCode == KMyKeyUpAsciiCode)
{
aSelection = EKeyUpArrow;
}
if(asciiCode == KMyKeyLeftAsciiCode)
{
aSelection = EKeyLeftArrow;
}
if(asciiCode == KMyKeyRightAsciiCode)
{
aSelection = EKeyEnter;
}
if(asciiCode == KMyKeyDownAsciiCode)
{
aSelection = EKeyDownArrow;
}
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: Recalculate
Description: Recalculates visible menu elements
Parameters: TInt aItemCount :in: Menu items count
Return Values: None
Errors/Exceptions: None
Status: Approved
-------------------------------------------------------------------------------
*/
void CMenu::Recalculate( TInt aItemCount )
{
TInt oldItemCount = iItemCount;
iItemCount = aItemCount;
// If first time in menu, update start and end positions
if ( ( iFirst == 0 ) && ( iLast == 0 ) || (iItemCount == 0)) //if there are no items, update start and end positions too
{
if ( iItemCount - 1 > iScreenSize )
{
iLast = iScreenSize;
}
else
{
iLast = iItemCount - 1;
}
iPosOnScreen = 0;
}
// New menu entry added, update last visible element if needed
else if ( oldItemCount < iItemCount )
{
if ( iFirst + iScreenSize < iItemCount )
{
iLast = iFirst + iScreenSize;
}
else
{
iLast = iItemCount - 1;
}
}
// Menu entry removed, update last visible element if needed
else if ( oldItemCount > iItemCount )
{
if ( iFirst + iScreenSize < iItemCount )
{
iLast = iFirst + iScreenSize;
}
else if ( iFirst > iItemCount - 1 )
{
iFirst = iItemCount - 1 - iScreenSize;
if ( iFirst < 0 )
{
iFirst = 0;
}
iLast = iItemCount - 1;
iPosOnScreen = iFirst - iLast;
}
else
{
iLast = iItemCount - 1;
}
if ( iFirst + iPosOnScreen > iLast )
{
iPosOnScreen = iLast - iFirst;
}
}
}
/*
-------------------------------------------------------------------------------
Class: CFileNameQueryView
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CFileNameQueryView* CFileNameQueryView::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CFileNameQueryView* self = new ( ELeave ) CFileNameQueryView();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CFileNameQueryView
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CFileNameQueryView::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName
)
{
CMenu::ConstructL( aConsole, aParent, aName);
}
/*
-------------------------------------------------------------------------------
Class: CFileNameQueryView
Method: ~CFileNameQueryView
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CFileNameQueryView::~CFileNameQueryView()
{
iTestModuleNames.ResetAndDestroy();
iTestModuleNames.Close();
}
/*
-------------------------------------------------------------------------------
Class: CFileNameQueryView
Method: ItemText
Description: Returns menu item text.
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CFileNameQueryView::ItemTexts( RRefArray<TDesC>& aArray )
{
iTestModuleNames.ResetAndDestroy();
// Add loaded module names to menu
TInt ret = iMain->UIStore().ListAllModules( iTestModuleNames );
if( ret != KErrNone )
{
return ret;
}
TInt count = iTestModuleNames.Count();
for( TInt i=0; i<count; i++ )
{
if( aArray.Append( *iTestModuleNames[i] ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CFileNameQueryView
Method: SelectL
Description: Process keypresses in menu. Just return the parent menu
Parameters: TKeyCode aSelection :in: Not used
TBool& aContinue :out: Has user pressed "Quit"?
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CFileNameQueryView::SelectL( TKeyCode aSelection,
TBool& aContinue )
{
MapKeyCode(aSelection);
if (aSelection == EKeyEnter || aSelection == EKeyRightArrow )
{
if( iPosOnScreen < iTestModuleNames.Count() )
{
TInt ret =
iMain->UIStore().AddTestModule( *iTestModuleNames[iPosOnScreen] );
if( ret != KErrNone )
{
TErrorNotification error;
error.iModule.Copy( _L("ConsoleUI") );
error.iText.Copy( _L("Failed to load test module ") );
error.iText.Append( *iTestModuleNames[iPosOnScreen] );
error.iText.Append( _L(" error "));
error.iText.AppendNum( ret );
iMain->Error( error );
}
return iParent;
}
else
{
return this;
}
}
return CMenu::SelectL( aSelection, aContinue );
}
/*
-------------------------------------------------------------------------------
Class: CMainMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
const TDesC& aHeader :in: Text containing STIF version information
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CMainMenu* CMainMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
const TDesC& aHeader)
{
CMainMenu* self = new ( ELeave ) CMainMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName, aHeader );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
CMainMenu
Method: ~CMainMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMainMenu::~CMainMenu()
{
delete iOutputView;
iOutputView = NULL;
delete iOperationMenu;
iOperationMenu = NULL;
}
/*
-------------------------------------------------------------------------------
Class: CMainMenu
Method: ItemText
Description: Returns menu item text. Add "Exit" to normal SelectLion
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CMainMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
TInt ret = CMenu::ItemTexts( aArray );
if ( ret != KErrNone )
{
return ret;
}
// Add Exit to last one in menu
if( aArray.Append( KExitTxt ) != KErrNone )
{
return KErrNoMemory;
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CMainMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
const TDesC& aHeader :in: Text containing STIF version information
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMainMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
const TDesC& aHeader
)
{
CMenu::ConstructL( aConsole, aParent, aName, aHeader);
iOutputView = NULL;
iOperationMenu = NULL;
}
/*
-------------------------------------------------------------------------------
Class: CMainMenu
Method: SelectL
Description: Process keypresses in menu. Handle SelectLion in this
method, other keys are handles in CMenu class.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CMainMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
// If SelectLion == "exit" and right or enter
if (aSelection == EKeyEnter || aSelection == EKeyRightArrow )
{
if ( iPosOnScreen == iItemCount-1 )
{
// Exit
aContinue = EFalse;
return this;
}
}
// Normal menu handling
CMenu* tmp = CMenu::SelectL(aSelection, aContinue);
return tmp;
}
/*
-------------------------------------------------------------------------------
Class: CMainMenu
Method: CreateOutputViewL
Description: Creates test case output view.
Parameters: CMenu* aParent: parent menu for case operation menu
Return Values: CMenu* New menu
Errors/Exceptions: Leaves is CCaseExecutionView menu leaves during creation
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CMainMenu::CreateOutputViewL(CMenu* aParent)
{
// Get test cases that have been run
RRefArray<CStartedTestCase> startedTestCases;
CleanupClosePushL(startedTestCases);
CMenu* res = NULL;
startedTestCases.Reset();
if(iMain->UIStore().StartedTestCases(startedTestCases, CUIStoreIf::EStatusAll) == KErrNone)
{
TInt count = startedTestCases.Count();
if(count > 0)
{
// Create menu with execution info
const CStartedTestCase* caseContainer = &startedTestCases[count - 1];
delete iOutputView;
iOutputView = NULL;
delete iOperationMenu;
iOperationMenu = NULL;
iOperationMenu = CCaseOperationMenu::NewL(iMain,
aParent, //back to parent menu
caseContainer->TestInfo().TestCaseTitle(),
caseContainer
);
iOutputView = CCaseExecutionView::NewL(iMain,
iOperationMenu, //back to Case Operation Menu
caseContainer->TestInfo().TestCaseTitle(),
caseContainer
);
res = iOutputView;
}
}
CleanupStack::PopAndDestroy(&startedTestCases);
return res;
}
/*
-------------------------------------------------------------------------------
Class: CModuleListView
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CModuleListView* CModuleListView::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CModuleListView* self = new ( ELeave ) CModuleListView();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CModuleListView
Method: ~CModuleListView
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CModuleListView::~CModuleListView()
{
delete iModuleAdd;
}
/*
-------------------------------------------------------------------------------
Class: CModuleListView
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: Leaves if parent class ConstructL leaves
Leaves if module can't be appended to list
Status: Draft
-------------------------------------------------------------------------------
*/
void CModuleListView::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName
)
{
CMenu::ConstructL( aConsole, aParent, aName);
// Construct module menu
iModuleAdd = CFileNameQueryView::NewL ( iMain, this, KSelectMenuTxt );
}
/*
-------------------------------------------------------------------------------
Class: CModuleListView
Method: ItemText
Description: Returns menu item text.
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CModuleListView::ItemTexts( RRefArray<TDesC>& aArray )
{
// Add also "Add module" text
if( aArray.Append( KAddMenuTxt ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KLoadMenuTxt ) != KErrNone )
{
return KErrNoMemory;
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CModuleListView
Method: PrintMenuL
Description: Prints the menu
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CModuleListView::PrintMenuL( TUpdateType aType )
{
// Get module names
RRefArray<TDesC> modules;
TInt ret = iMain->UIStore().Modules( modules );
CMenu::PrintMenuL( aType );
// Add loaded module names to menu
if( ret != KErrNone )
{
modules.Reset();
modules.Close();
return;
}
TBuf<KMaxLineLength> line;
TInt count = modules.Count();
for( TInt i=0; i<count; i++ )
{
line = _L(" ");
LimitedAppend ( line, modules[i] );
// Print the line
Print(line);
}
modules.Reset();
modules.Close();
}
/*
-------------------------------------------------------------------------------
Class: CModuleListView
Method: SelectL
Description: Process keypresses in menu. Handle right arrow and enter
here, others in parent menu.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CModuleListView::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
if( ( aSelection == EKeyRightArrow ||
aSelection == EKeyEnter ) )
{
if( iPosOnScreen == EAddMenuTxtItem )
{
return iModuleAdd;
}
else if( iPosOnScreen == ELoadMenuTxtItem )
{
iMain->UIStore().LoadAllModules();
return this;
}
else
{
return this;
}
}
return CMenu::SelectL( aSelection, aContinue );
}
/*
-------------------------------------------------------------------------------
Class: CCaseStartMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
TBool aShowOutput :in: Show output after test case is run
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CCaseStartMenu* CCaseStartMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
TBool aShowOutput)
{
CCaseStartMenu* self = new ( ELeave ) CCaseStartMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName, aShowOutput );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CCaseStartMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CCaseStartMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
TBool aShowOutput
)
{
iShowOutput = aShowOutput;
CMenu::ConstructL( aConsole, aParent, aName);
}
/*
-------------------------------------------------------------------------------
CCaseStartMenu
Method: ~CCaseStartMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CCaseStartMenu::~CCaseStartMenu()
{
iTestCases.Close();
iMapFilteredToAll.Reset();
iMapFilteredToAll.Close();
}
/*
-------------------------------------------------------------------------------
Class: CCaseStartMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CCaseStartMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
iTestCases.Reset();
TInt ret = iMain->UIStore().TestCases( iTestCases );
if( ret != KErrNone )
{
return ret;
}
const RPointerArray<TDesC> &filters = iMain->GetFilterArray();
const TInt filterindex = iMain->GetFilterIndex();
iMapFilteredToAll.Reset();
TInt count = iTestCases.Count();
for( TInt i = 0; i < count; i++ )
{
//If user has chosen filter, let's apply it
if(filterindex > 0) //skip the first filter which always is "No filter"
{
//Check whether test title is matching the applied filter
iTitleLowerCase.Copy(iTestCases[i].TestCaseTitle());
iTitleLowerCase.LowerCase();
iFilterLowerCase.Copy(*filters[filterindex]);
iFilterLowerCase.LowerCase();
if(iTitleLowerCase.Match(iFilterLowerCase) != KErrNotFound)
{
ret = aArray.Append(iTestCases[i].TestCaseTitle());
if(ret != KErrNone)
{
return ret;
}
ret = iMapFilteredToAll.Append(i);
if(ret != KErrNone)
{
return ret;
}
}
}
else
{
ret = aArray.Append( iTestCases[i].TestCaseTitle() );
if(ret != KErrNone)
{
return ret;
}
ret = iMapFilteredToAll.Append(i);
if(ret != KErrNone)
{
return ret;
}
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CCaseStartMenu
Method: SelectL
Description: Process keypresses in menu. Handle enter and right arrow here,
others in CMenu::SelectL.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CCaseStartMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
switch ( aSelection )
{
case EKeyEnter:
case EKeyRightArrow:
{
// Start the case
if ( (iFirst + iPosOnScreen) < iMapFilteredToAll.Count() ) //changed from iTestCases to iMapFilteredToAll, because first table keeps info about all test cases, and second one about filtered cases
{
TInt index;
User::LeaveIfError(
iMain->UIStore().StartTestCase(
iTestCases[iMapFilteredToAll[iFirst + iPosOnScreen]], index ) );
// Create output screen (menu) if needed
if(iShowOutput)
{
CMenu* m = iMain->GetMainMenu()->CreateOutputViewL(iParent);
if(m)
return m;
}
return iParent;
}
else
{
return this;
}
}
default:
return CMenu::SelectL( aSelection, aContinue);
}
}
/*
-------------------------------------------------------------------------------
CMultipleBaseMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CMultipleBaseMenu* CMultipleBaseMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CMultipleBaseMenu* self = new ( ELeave ) CMultipleBaseMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
CMultipleBaseMenu
Method: CMultipleBaseMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMultipleBaseMenu::CMultipleBaseMenu():
iSetFinished( ETrue ),
iRunType( ERunSequential ),
iMenuTotCount( 0 ),
iMenuCount( 0 )
{
iMenuCount = EChangeAll + 1;
iMenuTotCount = iMenuCount;
}
/*
-------------------------------------------------------------------------------
CMultipleBaseMenu
Method: ~CMultipleBaseMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMultipleBaseMenu::~CMultipleBaseMenu()
{
iSetState.Close();
}
/*
-------------------------------------------------------------------------------
Class: CMultipleBaseMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMultipleBaseMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName
)
{
CCaseStartMenu::ConstructL( aConsole, aParent, aName );
}
/*
-------------------------------------------------------------------------------
Class: CMultipleBaseMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CMultipleBaseMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
if ( iSetFinished )
{
if( aArray.Append( KChangeAll ) != KErrNone )
{
return KErrNoMemory;
}
if( iUpdateType == EMenuPrint )
{
TInt ret = UpdateTestCases();
if( ret != KErrNone )
{
return ret;
}
}
TInt count = iTestCases.Count();
for( TInt j=0; j<count; j++ )
{
if( aArray.Append( iTestCases[j].TestCaseTitle() )
!= KErrNone )
{
return KErrNoMemory;
}
if( aArray.Count() > iSetState.Count())
{
// Appends iSetState only if aArray's size is bigger @js
if( iSetState.Append(EFalse) != KErrNone )
{
return KErrNoMemory;
}
}
}
}
else
{
if( aArray.Append( KCancelSet ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CMultipleBaseMenu
Method: AppendBefore
Description: Append text before line.
Parameters: TInt aLine: in: line number
TDes& aLine: in: line text
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMultipleBaseMenu::AppendBefore( TInt aLineNum, TDes& aLine )
{
CMenu::AppendBefore( aLineNum, aLine );
if( ( aLine.MaxLength() - aLine.Length() ) < 2 )
{
return;
}
if( aLineNum >= iMenuTotCount )
{
if ( iSetState[ aLineNum - iMenuTotCount ] )
{
aLine.Append(_L("S "));
}
else
{
aLine.Append(_L(" "));
}
}
}
/*
-------------------------------------------------------------------------------
Class: CMultipleBaseMenu
Method: SelectL
Description: Process keypresses in menu. Handle enter and right arrow here,
others in CMenu::SelectL.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CMultipleBaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
if ( iSetFinished )
{
if ( ( aSelection == EKeyEnter ) || ( aSelection == EKeyRightArrow ) )
{
// CMultipleBaseMenu relative position
TInt pos = iFirst + iPosOnScreen - iMenuTotCount + iMenuCount;
if( pos == EChangeAll )
{
TInt count = iTestCases.Count();
// Change all
for (TInt i = 0; i < count; i++)
{
iSetState[i] = !iSetState[i];
}
return this;
}
else
{
// Normal item, change state...
iSetState[ iFirst + iPosOnScreen - iMenuTotCount ] =
!iSetState[ iFirst + iPosOnScreen - iMenuTotCount ];
return this;
}
}
return CMenu::SelectL( aSelection, aContinue );
}
else
{
switch ( aSelection )
{
case EKeyEnter:
case EKeyRightArrow:
{
if ( iOngoingCaseContainer != NULL )
{
iOngoingCaseContainer->UIEngineContainer().CancelTest();
}
iSetFinished = ETrue;
iFirst = 0;
iLast = 0;
return this;
}
default:
return CMenu::SelectL( aSelection, aContinue );
}
}
}
/*
-------------------------------------------------------------------------------
Class: CMultipleBaseMenu
Method: CheckIfAnyCaseIsSelected
Description: Checks if any of testcases was selected in multiple selection menu
Parameters: TInt aCount number of testcases in multiple selection menu
Return Values: ETrue if any testcase was selected, EFalse if none of testcases was selected
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
TBool CMultipleBaseMenu::CheckIfAnyCaseIsSelected(TInt aCount)
{
TInt currentPos = 0;
for(; currentPos<aCount; currentPos++)
{
//if any of testcases was selected then return true
if (iSetState[currentPos])
return ETrue;
}
//if none of testcases was selected then return false
return EFalse;
}
/*
-------------------------------------------------------------------------------
Class: CMultipleBaseMenu
Method: SignalL
Description: Handle test case starts
Parameters: CStartedTestCase* aContainer: in: CStartedTestCase container
Return Values: None
Errors/Exceptions: None
Status: Approved
-------------------------------------------------------------------------------
*/
void CMultipleBaseMenu::SignalL( CStartedTestCase* /*aContainer*/ )
{
TInt count = iTestCases.Count();
TBool started = EFalse;
TInt index;
TInt err = KErrNone;
// Counter to prevent infinite loop when cases can't be started at all
// when running cases in repeat mode.
TInt casesChecked = 0;
// If cases are not aborted or not in last case and at least one test
// case was selected, start a new one
if ( !iSetFinished && iCurrentRunPos != count && CheckIfAnyCaseIsSelected(count) )
{
// Search next case from set and execute it.
while( iCurrentRunPos < count )
{
if ( iSetState[iCurrentRunPos] )
{
err = iMain->UIStore().StartTestCase(
iTestCases[ iCurrentRunPos ],
index );
iCurrentRunPos++;
casesChecked++;
// Go to start of list, if running cases in repeat mode.
// In other modes, just get out from the main loop
if( ( iRunType == ERunRepeatSequential ) &&
( iCurrentRunPos >= count ) )
{
// Restart from first one on next time.
iCurrentRunPos = 0;
}
// Handle out of memory error separately, because there is
// always new test case result display constructed when
// starting case => Starting more new cases uses more memory
// and it will not work, so stop starting new cases.
if( err == KErrNoMemory )
{
iSetFinished = ETrue;
break;
}
// Get pointer to ongoing case in case that user wants to
// cancel it.
iOngoingCaseContainer =
&iMain->UIStore().StartedTestCaseL( index );
// Store pointer to this object to allow
// SignalL call when test case is completed
iOngoingCaseContainer->iBackPtr = (TAny*)this;
if( err != KErrNone )
{
TFullTestResult result;
result.iTestResult.iResult = err;
result.iTestResult.iResultDes.Copy(
_L("Failed to start testcase") );
// Prevent infinite loop in case, where
// ERunRepeatSequential and ALL cases fail to start.
if ( iRunType == ERunRepeatSequential &&
casesChecked == count )
{
// In this state, started = EFalse so final check
// stops running
break;
}
}
else if( ( iRunType == ERunSequential ) ||
( iRunType == ERunRepeatSequential ) )
{
started = ETrue;
break;
}
}
else
{
iCurrentRunPos++;
casesChecked++;
// Go to start of list, if running cases in repeat mode.
// In other modes, just get out from the main loop
if( ( iRunType == ERunRepeatSequential ) &&
( iCurrentRunPos >= count ) )
{
// Restart from first one
iCurrentRunPos = 0;
}
}
}
}
if ( err == KErrNoMemory )
{
iMain->ExitWithNoMemoryErrorMessage();
}
// If nothing was selected, then mark set as finished.
// Or running cases at same time, so all have been started.
if ( started == EFalse )
{
iFirst = 0;
iLast = 0;
iSetFinished = ETrue;
iCurrentRunPos = 0;
}
}
/*
-------------------------------------------------------------------------------
Class: CMultipleBaseMenu
Method: UpdateTestCases
Description:
Parameters:
Return Values:
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CMultipleBaseMenu::UpdateTestCases()
{
// Update test cases
iTestCases.Reset();
iSetState.Reset();
return iMain->UIStore().TestCases( iTestCases );
}
/*
-------------------------------------------------------------------------------
CMultipleCaseMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CMultipleCaseMenu* CMultipleCaseMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CMultipleCaseMenu* self = new ( ELeave ) CMultipleCaseMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
CMultipleCaseMenu
Method: CMultipleCaseMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMultipleCaseMenu::CMultipleCaseMenu()
{
iMenuItemsCount = ERepeatRunSelection + 1;
iMenuItemsCount++; //Select all between already selected
iMenuTotCount += iMenuItemsCount;
}
/*
-------------------------------------------------------------------------------
CMultipleCaseMenu
Method: ~CMultipleCaseMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMultipleCaseMenu::~CMultipleCaseMenu()
{
}
/*
-------------------------------------------------------------------------------
Class: CMultipleCaseMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CMultipleCaseMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName
)
{
CCaseStartMenu::ConstructL( aConsole, aParent, aName );
}
/*
-------------------------------------------------------------------------------
Class: CMultipleCaseMenu
Method: StartRunningL
Description: Start running multiple cases.
Parameters: TRunType aRunType: in: Running type
const TDesC& aModule: in: module name
const TDesC& aTestCaseFile: in: test case file name
Return Values: None
Errors/Exceptions: Leaves on error
Status: Draft
-------------------------------------------------------------------------------
*/
void CMultipleCaseMenu::StartRunningL( TRunType aRunType,
const TDesC& aModule,
const TDesC& aTestCaseFile )
{
// Update test cases
iTestCases.Reset();
iSetState.Reset();
User::LeaveIfError(
iMain->UIStore().TestCases( iTestCases, aModule, aTestCaseFile ) );
// Select all for running
TInt count = iTestCases.Count();
for( TInt j=0; j<count; j++ )
{
User::LeaveIfError( iSetState.Append(ETrue) );
}
// Start running
iCurrentRunPos = 0;
iSetFinished = EFalse;
iRunType = aRunType;
SignalL ( NULL );
}
/*
-------------------------------------------------------------------------------
Class: CMultipleCaseMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CMultipleCaseMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
if ( iSetFinished )
{
if( aArray.Append( KRunSequentially ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KRunParallel ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KRepeatRunSequentially ) != KErrNone )
{
return KErrNoMemory;
}
if(aArray.Append(KSelectFromTo) != KErrNone)
{
return KErrNoMemory;
}
}
TInt ret = CMultipleBaseMenu::ItemTexts(aArray);
if(ret != KErrNone)
{
return ret;
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CMultipleCaseMenu
Method: SelectL
Description: Process keypresses in menu. Handle enter and right arrow here,
others in CMenu::SelectL.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CMultipleCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
if ( iSetFinished )
{
switch ( aSelection )
{
case EKeyEnter:
case EKeyRightArrow:
{
if ( iFirst + iPosOnScreen == ERunSelection )
{
// Start the first one
iCurrentRunPos = 0;
iSetFinished = EFalse;
iRunType = ERunSequential;
SignalL ( NULL );
return iParent;
}
else if ( iFirst + iPosOnScreen == ERunSelectionParaller )
{
// Start the first one
iCurrentRunPos = 0;
iSetFinished = EFalse;
iRunType = ERunParallel;
SignalL ( NULL );
return iParent;
}
else if ( iFirst + iPosOnScreen == ERepeatRunSelection )
{
// Start the first one
iCurrentRunPos = 0;
iSetFinished = EFalse;
iRunType = ERunRepeatSequential;
SignalL ( NULL );
return iParent;
}
else if(iFirst + iPosOnScreen == ESelectFromTo)
{
TInt count = iTestCases.Count();
TInt indexFirst = count;
TInt indexLast = count - 1;
TInt i;
// Find first test case which is set
for(i = 0; i < count; i++)
{
if(iSetState[i])
{
indexFirst = i;
break;
}
}
// Find last test case which is set
if(indexFirst < count)
{
for(i = count - 1; i > indexFirst; i--)
{
if(iSetState[i])
{
indexLast = i;
break;
}
}
// Set test cases between first and last
for(i = indexFirst; i <= indexLast; i++)
{
iSetState[i] = ETrue;
}
}
return this;
}
}
break;
default:
break;
}
}
return CMultipleBaseMenu::SelectL( aSelection, aContinue );
}
/*
-------------------------------------------------------------------------------
Class: CCaseMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
TCaseState aType :in: Case state
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CCaseMenu* CCaseMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
TInt aType )
{
CCaseMenu* self = new ( ELeave ) CCaseMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName, aType );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CCaseMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
TCaseState aType :in: Case state
Return Values: None
Errors/Exceptions: Leaves if parent class ConstructL leaves
Leaves if memory allocation fails
Leaves if CCaseOperation menu NewL leaves
Leaves if UpcateCaseListL leaves
Status: Draft
-------------------------------------------------------------------------------
*/
void CCaseMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
TInt aType
)
{
CMenu::ConstructL( aConsole, aParent, aName);
iType = aType;
}
/*
-------------------------------------------------------------------------------
Class: CCaseMenu
Method: ~CCaseMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CCaseMenu::~CCaseMenu()
{
delete iCaseOperationMenu;
iCaseOperationMenu = 0;
iTestCases.Close();
}
/*
-------------------------------------------------------------------------------
Class: CCaseMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CCaseMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
iTestCases.Reset();
TInt ret = iMain->UIStore().StartedTestCases( iTestCases, iType );
if ( ret != KErrNone )
{
return ret;
}
TInt count = iTestCases.Count();
for( TInt i=0; i<count; i++ )
{
if( aArray.Append( iTestCases[i].TestInfo().TestCaseTitle() ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CCaseMenu
Method: AppendBefore
Description: Append text before line.
Parameters: TInt aLine: in: line number
TDes& aLine: in: line text
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CCaseMenu::AppendBefore(TInt aLineNum, TDes& aLine)
{
CMenu::AppendBefore(aLineNum, aLine);
//START of --Add number to the test case title--
//First check how much space we need
TInt additionalSpace = 0;
TInt currentCount = aLineNum + 1;
if(currentCount >= 10000) additionalSpace = 10; //f.e. "10157521. "
else if(currentCount >= 1000) additionalSpace = 6; //f.e. "1157. "
else if(currentCount >= 100) additionalSpace = 5; //f.e. "101. "
else if(currentCount >= 10) additionalSpace = 4; //f.e. "15. "
else additionalSpace = 3; //f.e. "1. "
//Create descriptor, add content to it, and finally append to line
TBuf<20> num;
if(iTestCases[aLineNum].Status() == CUIStoreIf::EStatusRunning )
{
if( iTestCases[aLineNum].UIEngineContainer().State() == CUIEngineContainer::EPaused)
{
//If not enough space, return
if((aLine.MaxLength() - aLine.Length()) < additionalSpace + 4)
{
return;
}
num.Format(_L("%d.(P) "), currentCount);
}
else
{
//If not enough space, return
if((aLine.MaxLength() - aLine.Length()) < additionalSpace)
{
return;
}
num.Format(_L("%d."), currentCount);
}
}
aLine.Append(num);
}
//END of --Add number to test case title--
/*
-------------------------------------------------------------------------------
Class: CCaseMenu
Method: SelectL
Description: Process keypresses in menu. Handle Enter and Right Arrow
here, other will be handled in CMenu::SelectL
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
switch (aSelection)
{
case EKeyEnter:
case EKeyRightArrow:
{
if ( iFirst + iPosOnScreen < iTestCases.Count() )
{
delete iCaseOperationMenu;
iCaseOperationMenu = 0;
iCaseOperationMenu = CCaseOperationMenu::NewL(
iMain,
this,
iTestCases[iFirst + iPosOnScreen].TestInfo().TestCaseTitle(),
&iTestCases[iFirst + iPosOnScreen] );
return iCaseOperationMenu;
}
}
return this;
default:
// Let the parent class handle rest
return CMenu::SelectL(aSelection, aContinue);
}
}
/*
-------------------------------------------------------------------------------
Class: CCaseOperationMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
CStartedTestCase* aCaseContainer:in: Case container
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CCaseOperationMenu* CCaseOperationMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
const CStartedTestCase* aCaseContainer
)
{
CCaseOperationMenu* self = new ( ELeave ) CCaseOperationMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName, aCaseContainer );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CCaseOperationMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
CStartedTestCase* aCaseContainer:in: Case container
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CCaseOperationMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
const CStartedTestCase* aCaseContainer
)
{
CMenu::ConstructL( aConsole, aParent, aName);
iCaseContainer = aCaseContainer;
// Indicate that this menu contains prints, update when needed
iType = CUIStoreIf::EStatusExecuted;
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: ~CMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CCaseOperationMenu::~CCaseOperationMenu()
{
delete iView;
iView = 0;
}
/*
-------------------------------------------------------------------------------
Class: CCaseOperationMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CCaseOperationMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
if( iCaseContainer->Status() & CUIStoreIf::EStatusRunning )
{
if( aArray.Append( KOutputViewDes ) != KErrNone )
{
return KErrNoMemory;
}
// Set resume/pause text
if( iCaseContainer->UIEngineContainer().State() ==
CUIEngineContainer::EPaused )
{
if( aArray.Append( KResumeCaseDes ) != KErrNone )
{
return KErrNoMemory;
}
}
else
{
if( aArray.Append( KPauseCaseDes ) != KErrNone )
{
return KErrNoMemory;
}
}
if( aArray.Append( KAbortCaseDes ) != KErrNone )
{
return KErrNoMemory;
}
}
else
{
if(aArray.Append(KRestartCaseDes) != KErrNone)
{
return KErrNoMemory;
}
if( aArray.Append( KOutputViewDes ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: PrintMenuL
Description: Prints the menu and test case specific information after that.
Parameters: None
Return Values: None
Errors/Exceptions: Leaves if FormatL leaves
Status: Draft
-------------------------------------------------------------------------------
*/
void CCaseOperationMenu::PrintMenuL( TUpdateType aType )
{
// Print menu
CMenu::PrintMenuL( aType );
// Print the result description + result code
// If case is finished, print also result string
TInt state = iCaseContainer->Status();
if ( ! ( state & CUIStoreIf::EStatusRunning ) )
{
TName resultLine;
Print (_L(""));
resultLine.Append(_L("Result info: ") );
if( state & CUIStoreIf::EStatusPassed )
{
resultLine.Append( _L("Passed" ) );
}
else if( state & CUIStoreIf::EStatusFailed )
{
resultLine.Append( _L("Failed" ) );
}
else if( state & CUIStoreIf::EStatusAborted )
{
resultLine.Append( _L("Aborted" ) );
}
else if( state & CUIStoreIf::EStatusCrashed )
{
resultLine.Append( _L("Crashed" ) );
}
PrintMulti( resultLine );
resultLine.Zero();
// Print test results
if( !( ( state & CUIStoreIf::EStatusAborted ) ||
( state & CUIStoreIf::EStatusCrashed ) ||
( state & CUIStoreIf::EStatusPassed ) ) )
{
resultLine.Format(_L("Result code %d"),
iCaseContainer->Result().iTestResult.iResult );
PrintMulti ( resultLine );
}
if( iCaseContainer->Result().iCaseExecutionResultType ==
TFullTestResult::ECaseErrorFromModule )
{
PrintMulti ( _L("Error from RunTestCase():"));
}
// Print result descriptor if that is available
const TDesC& des = iCaseContainer->Result().iTestResult.iResultDes;
if ( des.Length() >0 )
{
PrintMulti(des);
}
// Print abort code if that is available
if( ( state & CUIStoreIf::EStatusAborted ) ||
( state & CUIStoreIf::EStatusCrashed ) )
{
// Print abort type, if that is available
TFullTestResult::TCaseExecutionResult res =
iCaseContainer->Result().iCaseExecutionResultType;
if ( res == TFullTestResult::ECaseLeave ||
res == TFullTestResult::ECasePanic ||
res == TFullTestResult::ECaseException ||
res == TFullTestResult::ECaseErrorFromModule ||
res == TFullTestResult::ECaseSuicided )
{
TInt code = iCaseContainer->Result().iCaseExecutionResultCode;
resultLine.Format(_L("Code %d (0x%x)"), code, code );
PrintMulti ( resultLine );
}
}
// Print start and end times
const TInt KTimeFieldLength = 30;
TBuf<KTimeFieldLength> time;
_LIT(KDateString,"%-B%:0%J%:1%T%:2%S%.%*C4%:3%+B");
resultLine = _L("Started:");
iCaseContainer->Result().iStartTime.FormatL(time,KDateString);
resultLine.Append(time);
PrintMulti (resultLine);
resultLine = _L("Completed:");
iCaseContainer->Result().iEndTime.FormatL(time,KDateString);
resultLine.Append(time);
PrintMulti (resultLine);
}
}
/*
-------------------------------------------------------------------------------
Class: CCaseOperationMenu
Method: SelectL
Description: Process keypresses in menu. Handle Enter and right arrow
here, others are handled in parent menu.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CCaseOperationMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
if (aSelection == EKeyEnter || aSelection == EKeyRightArrow )
{
// restartOptionModifier is used because when test case is running
// restart option is not available (and visible) and that's why
// we need to modify switch by 1.
// When test case is finished, restart option becomes available
// and is put at the first place.
TInt restartOptionModifier = 0;
if(iCaseContainer->Status() & CUIStoreIf::EStatusRunning)
restartOptionModifier = 1;
switch (iPosOnScreen + iFirst + restartOptionModifier)
{
case ERestartCase:
{
TInt index;
User::LeaveIfError(iMain->UIStore().StartTestCase(iCaseContainer->TestInfo(), index));
// Create output screen
CMenu* m = iMain->GetMainMenu()->CreateOutputViewL(iParent);
return m;
}
case EOutputView:
{
delete iView;
iView = 0;
iView = CCaseExecutionView::NewL(
iMain,
this,
iCaseContainer->TestInfo().TestCaseTitle(),
iCaseContainer );
return iView;
}
case EPauseResume:
if( iCaseContainer->UIEngineContainer().State() ==
CUIEngineContainer::ERunning )
{
// Pausing a running case
iCaseContainer->UIEngineContainer().PauseTest();
}
else if( iCaseContainer->UIEngineContainer().State() ==
CUIEngineContainer::EPaused )
{
// Resuming a paused case
iCaseContainer->UIEngineContainer().ResumeTest();
}
// No other possibilities
return this;
case EAbortCase:
iCaseContainer->UIEngineContainer().CancelTest();
break;
}
return this;
}
else
{
return CMenu::SelectL(aSelection, aContinue);
}
}
/*
-------------------------------------------------------------------------------
Class: CCaseExecutionView
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
CStartedTestCase* aCase :in: Case container
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CCaseExecutionView* CCaseExecutionView::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
const CStartedTestCase* aCase )
{
CCaseExecutionView* self = new ( ELeave ) CCaseExecutionView();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName, aCase );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CCaseExecutionView
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
CStartedTestCase* aCase :in: Case container
Return Values: None
Errors/Exceptions: Leaves if parent class ConstructL leaves
Status: Draft
-------------------------------------------------------------------------------
*/
void CCaseExecutionView::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
const CStartedTestCase* aCase
)
{
CMenu::ConstructL( aConsole, aParent, aName );
iCase = aCase;
// Indicate that this menu contains prints, update when needed
iType = CUIStoreIf::EPrintUpdate;
iLine = 0;
}
/*
-------------------------------------------------------------------------------
CCaseExecutionView
Method: ~CCaseExecutionView
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CCaseExecutionView::~CCaseExecutionView()
{
delete iLineTextBuf;
}
/*
-------------------------------------------------------------------------------
Class: CMenu
Method: PrintMenuL
Description: Prints the menu. Show the test status and the test case
print statements.
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CCaseExecutionView::PrintMenuL( TUpdateType /*aType*/ )
{
if( iShowLine )
{
// User want to see whole line
iConsole->ClearScreen();
this->PrintMulti( iLineTextBuf->Des() );
return;
}
// Print the status
TName tmp;
TInt state = iCase->Status();
if( state & CUIStoreIf::EStatusRunning )
{
if( iCase->UIEngineContainer().State() ==
CUIEngineContainer::EPaused )
{
tmp = _L("Paused");
}
else
{
tmp = _L("Running");
}
}
else if( state & CUIStoreIf::EStatusPassed )
{
tmp = _L("Passed");
}
else if( state & CUIStoreIf::EStatusFailed )
{
tmp = _L("Failed");
}
else if( state & CUIStoreIf::EStatusAborted )
{
tmp = _L("Aborted");
}
else if( state & CUIStoreIf::EStatusCrashed )
{
tmp = _L("Aborted");
}
else
{
tmp = _L("Unknown");
}
// Clear screen.
iConsole->ClearScreen();
TBuf<KMaxLineLength> line;
line.Append(_L(" : "));
LimitedAppend(line, iCase->TestInfo().TestCaseTitle() );
Print( line );
const RPointerArray<CTestProgress>& prints = iCase->PrintArray();
Recalculate( prints.Count() );
// Print the print statements.
for ( TInt i = iFirst; i <= iLast; i++ )
{
line.Zero();
if( iLine == i )
{
line = _L( "*" ); // For indicating current line
}
line.Append( prints[i]->iDescription );
line.Append(_L(" : "));
LimitedAppend(line, prints[i]->iText );
// Print the line
TSize screenSize;
//screenSize = iConsole->ScreenSize();
iConsole->Size(screenSize);
Print ( line.Left(screenSize.iWidth ) );
}
}
/*
-------------------------------------------------------------------------------
Class: CCaseExecutionView
Method: SelectL
Description: Process keypresses in menu. Either updates position in
menu or returns new menu.
Parameters: TKeyCode aSelection: in: Key
TBool& aContinue: out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CCaseExecutionView::SelectL( TKeyCode aSelection, TBool& /*aContinue*/ )
{
iShowLine = EFalse;
MapKeyCode(aSelection);
// Take prints
const RPointerArray<CTestProgress>& prints = iCase->PrintArray();
switch( aSelection )
{
case EKeyEnter:
case EKeyRightArrow:
{
// Check that not out of range(too many EKeyUpArrow or EKeyDownArrow)
if( iLine >= prints.Count() || iLine < 0)
{
// do nothing
break;
}
TInt extra = 3; // ' : '
TInt length( 0 );
length = length + prints[iLine]->iDescription.Length();
length = length + prints[iLine]->iText.Length();
// Selected print line in seperate(operation will do in
// CCaseExecutionView::PrintMenuL() method )
delete iLineTextBuf;
iLineTextBuf = NULL;
TRAPD( ret, iLineTextBuf = HBufC::NewL( length + extra ) );
if( ret != KErrNone )
{
User::InfoPrint( _L("Line show failed, maybe out of memory!!!") );
break;
}
TPtr ptr = iLineTextBuf->Des();
ptr.Copy( prints[iLine]->iDescription );
ptr.Append( _L( " : " ) );
ptr.Append( prints[iLine]->iText );
iShowLine = ETrue;
break;
}
case EKeyLeftArrow:
{
return iParent;
}
// Go down
case EKeyDownArrow:
{
if ( iFirst + iPosOnScreen == iItemCount - 1 )
{
// If end of the list, go to beginning
iPosOnScreen = 0;
iFirst = 0;
iLast = iScreenSize;
if ( iLast > iItemCount - 1 )
{
iLast = iItemCount - 1;
}
iLine = 0;
}
else
{
if ( iPosOnScreen == iScreenSize )
{
iLast++;
iFirst++;
}
else
{
// Going down "in-screen", no need to update items
iPosOnScreen++;
}
iLine++;
}
break;
}
// Go Up
case EKeyUpArrow:
{
if ( iFirst + iPosOnScreen == 0 )
{
// If in the beginning of the list
iLast = iItemCount - 1;
iFirst = iLast - iScreenSize;
if ( iFirst < 0 )
{
iFirst = 0;
}
iPosOnScreen = iLast - iFirst;
iLine = iItemCount - 1;
}
else
{
if ( iPosOnScreen == 0 )
{
iLast--;
iFirst--;
}
else
{
iPosOnScreen--;
}
iLine--;
}
break;
}
// Additional keys
case EKeyHome:
case '3':
iPosOnScreen = 0;
iLine = 0;
iFirst = 0;
iLast = iScreenSize;
if ( iLast > iItemCount - 1 )
{
iLast = iItemCount - 1;
}
break;
case EKeyEnd:
case '9':
iLast = iItemCount - 1;
iFirst = iLast - iScreenSize;
iLine = iItemCount - 1;
if ( iFirst < 0 )
{
iFirst = 0;
}
iPosOnScreen = iLast - iFirst;
break;
case EKeyPageUp:
case '1':
iFirst = iFirst - iScreenSize;
iLast = iLast - iScreenSize;
if ( iFirst < 0 )
{
iFirst = 0;
iLast = iScreenSize;
if ( iLast > iItemCount - 1 )
{
iLast = iItemCount - 1;
}
iPosOnScreen = 0;
}
iLine = iLine - iScreenSize;
if ( iLine < 0 )
{
iLine = 0;
}
break;
case EKeyPageDown:
case '7':
iFirst = iFirst + iScreenSize;
iLast = iLast + iScreenSize;
// Going too far
if ( iLast > iItemCount - 1 )
{
iLast = iItemCount - 1;
iFirst = iLast - iScreenSize;
if ( iFirst < 0 )
{
iFirst = 0;
}
iPosOnScreen = iLast - iFirst;
}
iLine = iLine + iScreenSize;
if ( iLine > iItemCount - 1 )
{
iLine = iItemCount - 1;
}
break;
default:
{
break;
}
}
return this;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetMenu* CTestSetMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CTestSetMenu* self = new ( ELeave ) CTestSetMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetMenu
Method: CTestSetMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetMenu::CTestSetMenu():
iTestSetCreated( EFalse )
{
iTestSetName.Copy( KDefaultSetName );
}
/*
-------------------------------------------------------------------------------
Class: CTestSetMenu
Method: ~CTestSetMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetMenu::~CTestSetMenu()
{
delete iSubMenu;
iSubMenu = 0;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: Leaves if parent class ConstructL leaves
Leaves if module can't be appended to list
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName
)
{
CMenu::ConstructL( aConsole, aParent, aName);
}
/*
-------------------------------------------------------------------------------
Class: CTestSetMenu
Method: SetTestSetName
Description: Set test set name.
Parameters: const TFileName& aTestSetName: in: Test set name
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetMenu::SetTestSetFileName( const TFileName& aTestSetName )
{
iTestSetName.Copy( aTestSetName );
}
/*
-------------------------------------------------------------------------------
Class: CTestSetMenu
Method: ItemText
Description: Returns menu item text.
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CTestSetMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
if( !iTestSetCreated )
{
if( aArray.Append( KSetCreate ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KSetLoad ) != KErrNone )
{
return KErrNoMemory;
}
}
else
{
if( aArray.Append( KSetShow ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KSetStartSeq ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KSetStartPar ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KSetUnload ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KSetRemove ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KSetSave ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KSetCaseAdd ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KSetCaseRemove ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( KSetStartSeqNotRun ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetMenu
Method: PrintMenuL
Description: Prints the menu
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetMenu::PrintMenuL( TUpdateType aType )
{
if( iTestSetCreated )
{
RRefArray<CTestSetInfo> setInfos;
TInt ret = iMain->UIStore().TestSets( setInfos );
CMenu::PrintMenuL( aType );
if( ( ret != KErrNone ) ||
( setInfos.Count() != 1 ) )
{
// Should never ever happen
User::Panic( KTestSetMenu, KErrGeneral );
return;
}
const CTestSetInfo& set = setInfos[0];
setInfos.Reset();
setInfos.Close();
const RRefArray<const CTestInfo> testCases = set.TestCases();
TBuf<KMaxLineLength> line;
TInt count = testCases.Count();
for(TInt i = 0; i < count && i + ESetLAST <= iScreenSize; i++)
{
line = _L(" ");
LimitedAppend ( line, testCases[i].TestCaseTitle() );
// Print the line
Print(line);
}
}
else
{
CMenu::PrintMenuL( aType );
}
}
/*
-------------------------------------------------------------------------------
Class: CTestSetMenu
Method: SelectL
Description: Process keypresses in menu. Handle right arrow and enter
here, others in parent menu.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CTestSetMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
if( ( aSelection != EKeyRightArrow ) &&
( aSelection != EKeyEnter ) )
{
return CMenu::SelectL( aSelection, aContinue );
}
TInt ret = KErrNone;
if( !iTestSetCreated )
{
switch( iPosOnScreen )
{
case ESetCreate:
ret = iMain->UIStore().CreateTestSet( iTestSetName );
if( ret != KErrNone )
{
User::InfoPrint( _L("Test set creation failed") );
}
break;
case ESetLoad:
return iItems[0];
}
if( ret == KErrNone )
{
iTestSetCreated = ETrue;
}
}
else
{
CStartedTestSet::TSetType setType = CStartedTestSet::ESetSequential;
switch( iPosOnScreen )
{
case ESetShow:
// Add the test sets menu
delete iSubMenu;
iSubMenu = 0;
iSubMenu = CStartedTestSetMenu::NewL( iMain,
this,
_L("Started test sets menu"));
return iSubMenu;
case ESetUnload:
ret = iMain->UIStore().UnloadTestSet( iTestSetName );
if( ret != KErrNone )
{
User::InfoPrint( _L("Test set unload failed") );
}
iTestSetCreated = EFalse;
break;
case ESetRemove:
ret = iMain->UIStore().RemoveTestSet( iTestSetName );
if( ret != KErrNone )
{
User::InfoPrint( _L("Test set remove failed") );
}
iTestSetCreated = EFalse;
break;
case ESetCaseAdd:
delete iSubMenu;
iSubMenu = 0;
iSubMenu = CTestSetAddCaseMenu::NewL(
iMain,
this,
_L("Add test cases to test set"),
iTestSetName );
return iSubMenu;
case ESetCaseRemove:
delete iSubMenu;
iSubMenu = 0;
iSubMenu = CTestSetRemoveCaseMenu::NewL(
iMain,
this,
_L("Remove test cases from test set"),
iTestSetName );
return iSubMenu;
case ESetSave:
ret = iMain->UIStore().SaveTestSet2( iTestSetName );
if( ret != KErrNone )
{
User::InfoPrint( _L("Test set saving failed") );
}
break;
default:
// case ESetStartPar:
// setType = CStartedTestSet::ESetParallel;
// case ESetStartSeq:
//case ESetStartRep:
if( iPosOnScreen == ESetStartPar )
{
setType = CStartedTestSet::ESetParallel;
}
if( iPosOnScreen == ESetStartSeq || iPosOnScreen == ESetStartSeqNotRun)
{
RRefArray<CTestSetInfo> setInfos;
ret = iMain->UIStore().TestSets( setInfos );
if( ( ret != KErrNone ) ||
( setInfos.Count() != 1 ) )
{
// Should never ever happen
User::Panic( KTestSetMenu, KErrGeneral );
}
const CTestSetInfo& set = setInfos[0];
setInfos.Reset();
setInfos.Close();
TInt index;
ret = KErrGeneral;
if(iPosOnScreen == ESetStartSeq)
{
ret = iMain->UIStore().StartTestSet(set, index, setType);
}
else if(iPosOnScreen == ESetStartSeqNotRun)
{
ret = iMain->UIStore().StartTestSet(set, index, setType, ETrue);
}
if( ret != KErrNone )
{
User::InfoPrint( _L("Test set starting failed") );
}
}
break;
}
}
return this;
}
/**
-------------------------------------------------------------------------------
Class: CTestSetChoiceMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetChoiceMenu* CTestSetChoiceMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CTestSetChoiceMenu* self = new ( ELeave ) CTestSetChoiceMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetChoiceMenu
Method: CTestSetChoiceMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetChoiceMenu::CTestSetChoiceMenu()
{
}
/*
-------------------------------------------------------------------------------
Class: CTestSetChoiceMenu
Method: ~CTestSetChoiceMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetChoiceMenu::~CTestSetChoiceMenu()
{
iFileList.ResetAndDestroy();
iFileList.Close();
}
/*
-------------------------------------------------------------------------------
Class: CTestSetChoiceMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: Leaves if parent class ConstructL leaves
Leaves if module can't be appended to list
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetChoiceMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName
)
{
CMenu::ConstructL( aConsole, aParent, aName);
}
/*
-------------------------------------------------------------------------------
Class: CTestSetChoiceMenu
Method: ItemText
Description: Returns menu item text.
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CTestSetChoiceMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
TInt ret = iMain->UIStore().GetTestSetsList( aArray );
TRAPD( err,
//Assign aArray to iFileList, it is used in LoadTestSet
for( TInt i=0 ; i < aArray.Count(); i++)
{
iFileList.AppendL(aArray[i].AllocL());
}
); // TRAPD
return err;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetChoiceMenu
Method: PrintMenuL
Description: Prints the menu
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetChoiceMenu::PrintMenuL( TUpdateType aType )
{
iUpdateType = aType;
TBuf<KMaxLineLength> line;
// Clear display
iConsole->ClearScreen();
// Print menu title
Print( Name() );
RRefArray<TDesC> texts;
if( iMain->UIStore().GetTestSetsList( texts ) != KErrNone )
{
return;
}
TInt oldItemCount = iItemCount;
iItemCount = texts.Count();
// If first time in menu, update start and end positions
if( (iFirst == iLast) || // First time here..
( iLast >= iItemCount ) ||
( oldItemCount != iItemCount ) ) // Menu size changed
{
iLast = iItemCount - 1;
iPosOnScreen = 0;
// If "overflow", then adjust the end
if (iLast > iScreenSize )
{
iLast = iScreenSize;
}
}
// Print items
for ( TInt i = iFirst; i <= iLast; i++ )
{
line.Zero();
// Append text before line
AppendBefore( i, line );
// Get the menu line
LimitedAppend ( line, texts[i] );
// Print the line
Print(line);
}
texts.Close();
}
/*
-------------------------------------------------------------------------------
Class: CTestSetChoiceMenu
Method: SelectL
Description: Process keypresses in menu. Handle right arrow and enter
here, others in parent menu.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CTestSetChoiceMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
//return CMenu::SelectL( aSelection, aContinue );
//return iParent;
MapKeyCode(aSelection);
TInt ret = 0;
switch ( aSelection )
{
case EKeyEnter:
case EKeyRightArrow:
{
if(iPosOnScreen < iFileList.Count())
{
ret = iMain->UIStore().LoadTestSet( iFileList.operator [](iPosOnScreen)->Des() );
if (ret == KErrNone)
{
((CTestSetMenu*)iParent)->SetCreated();
((CTestSetMenu*)iParent)->SetTestSetFileName(iFileList.operator [](iPosOnScreen)->Des());
}
return iParent;
}
else
{
return this;
}
}
default:
break;
}
return CMenu::SelectL( aSelection, aContinue );
}
/*
-------------------------------------------------------------------------------
CTestSetAddCaseMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetAddCaseMenu* CTestSetAddCaseMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
TDesC& aTestSetName )
{
CTestSetAddCaseMenu* self =
new ( ELeave ) CTestSetAddCaseMenu( aTestSetName );
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
CTestSetAddCaseMenu
Method: CTestSetAddCaseMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetAddCaseMenu::CTestSetAddCaseMenu( TDesC& aTestSetName ):
iTestSetName( aTestSetName )
{
iMenuItemsCount = EAddSelected + 1;
iMenuTotCount += iMenuItemsCount;
}
/*
-------------------------------------------------------------------------------
CTestSetAddCaseMenu
Method: ~CTestSetAddCaseMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetAddCaseMenu::~CTestSetAddCaseMenu()
{
}
/*
-------------------------------------------------------------------------------
Class: CTestSetAddCaseMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetAddCaseMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CCaseStartMenu::ConstructL( aConsole, aParent, aName );
}
/*
-------------------------------------------------------------------------------
Class: CTestSetAddCaseMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CTestSetAddCaseMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
if ( iSetFinished )
{
if( aArray.Append( KAddSelected ) != KErrNone )
{
return KErrNoMemory;
}
}
return CMultipleBaseMenu::ItemTexts( aArray );
}
/*
-------------------------------------------------------------------------------
Class: CTestSetAddCaseMenu
Method: SelectL
Description: Process keypresses in menu. Handle enter and right arrow here,
others in CMenu::SelectL.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CTestSetAddCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
if ( iSetFinished )
{
switch ( aSelection )
{
case EKeyEnter:
case EKeyRightArrow:
{
if ( iFirst + iPosOnScreen == EAddSelected )
{
TInt count = iTestCases.Count();
for( TInt i=0; i<count; i++ )
{
if ( iSetState[i] )
{
TInt ret =
iMain->UIStore().AddToTestSet( iTestSetName,
iTestCases[i] );
if( ret != KErrNone )
{
User::InfoPrint( _L("Test case adding failed") );
}
}
}
return iParent;
}
}
break;
default:
break;
}
}
return CMultipleBaseMenu::SelectL( aSelection, aContinue );
}
/*
-------------------------------------------------------------------------------
CTestSetAddCaseMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetRemoveCaseMenu* CTestSetRemoveCaseMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
TDesC& aTestSetName )
{
CTestSetRemoveCaseMenu* self =
new ( ELeave ) CTestSetRemoveCaseMenu( aTestSetName );
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
CTestSetRemoveCaseMenu
Method: CTestSetRemoveCaseMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetRemoveCaseMenu::CTestSetRemoveCaseMenu( TDesC& aTestSetName ):
iTestSetName( aTestSetName )
{
iMenuItemsCount = ERemoveSelected + 1;
iMenuTotCount += iMenuItemsCount;
}
/*
-------------------------------------------------------------------------------
CTestSetRemoveCaseMenu
Method: ~CTestSetRemoveCaseMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetRemoveCaseMenu::~CTestSetRemoveCaseMenu()
{
}
/*
-------------------------------------------------------------------------------
Class: CTestSetRemoveCaseMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetRemoveCaseMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CCaseStartMenu::ConstructL( aConsole, aParent, aName );
}
/*
-------------------------------------------------------------------------------
Class: CTestSetRemoveCaseMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CTestSetRemoveCaseMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
if ( iSetFinished )
{
if( aArray.Append( KRemoveSelected ) != KErrNone )
{
return KErrNoMemory;
}
}
return CMultipleBaseMenu::ItemTexts( aArray );
}
/*
-------------------------------------------------------------------------------
Class: CTestSetRemoveCaseMenu
Method: SelectL
Description: Process keypresses in menu. Handle enter and right arrow here,
others in CMenu::SelectL.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CTestSetRemoveCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
if ( iSetFinished )
{
switch ( aSelection )
{
case EKeyEnter:
case EKeyRightArrow:
{
if ( iFirst + iPosOnScreen == ERemoveSelected )
{
TInt count = iTestCases.Count();
for( TInt i=0; i<count; i++ )
{
if ( iSetState[i] )
{
TInt ret =
iMain->UIStore().RemoveFromTestSet( iTestSetName,
iTestCases[i] );
if( ret != KErrNone )
{
User::InfoPrint( _L("Test case adding failed") );
}
}
}
return iParent;
}
}
break;
default:
break;
}
}
return CMultipleBaseMenu::SelectL( aSelection, aContinue );
}
/*
-------------------------------------------------------------------------------
Class: CTestSetRemoveCaseMenu
Method: UpdateTestCases
Description:
Parameters:
Return Values:
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CTestSetRemoveCaseMenu::UpdateTestCases()
{
TRAPD( err,
const CTestSetInfo& set = iMain->UIStore().TestSetL( iTestSetName );
const RRefArray<const CTestInfo>& testCases = set.TestCases();
// Update test cases
iTestCases.Reset();
iSetState.Reset();
TInt count = testCases.Count();
for( TInt i=0; i<count; i++ )
{
err = iTestCases.Append( testCases[i] );
if( err != KErrNone )
{
break;
}
}
); // TRAPD
return err;
}
/*
-------------------------------------------------------------------------------
Class: CCaseMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
TCaseState aType :in: Case state
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CStartedTestSetMenu* CStartedTestSetMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CStartedTestSetMenu* self = new ( ELeave ) CStartedTestSetMenu();
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CStartedTestSetMenu
Method: CStartedTestSetMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CStartedTestSetMenu::CStartedTestSetMenu()
{
iType = CUIStoreIf::ESetAll;
}
/*
-------------------------------------------------------------------------------
Class: CStartedTestSetMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
TCaseState aType :in: Case state
Return Values: None
Errors/Exceptions: Leaves if parent class ConstructL leaves
Leaves if memory allocation fails
Leaves if CCaseOperation menu NewL leaves
Leaves if UpcateCaseListL leaves
Status: Draft
-------------------------------------------------------------------------------
*/
void CStartedTestSetMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CMenu::ConstructL( aConsole, aParent, aName);
}
/*
-------------------------------------------------------------------------------
Class: CStartedTestSetMenu
Method: ~CStartedTestSetMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CStartedTestSetMenu::~CStartedTestSetMenu()
{
delete iCaseMenu;
iCaseMenu = 0;
iTestSets.Reset();
iTestSets.Close();
}
/*
-------------------------------------------------------------------------------
Class: CStartedTestSetMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CStartedTestSetMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
iTestSets.Reset();
TInt ret = iMain->UIStore().StartedTestSets( iTestSets, iType );
if ( ret != KErrNone )
{
return ret;
}
TInt count = iTestSets.Count();
for( TInt i=0; i<count; i++ )
{
if( aArray.Append( iTestSets[i].TestSetInfo().Name() ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CStartedTestSetMenu
Method: AppendBefore
Description: Append text before line.
Parameters: TInt aLine: in: line number
TDes& aLine: in: line text
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CStartedTestSetMenu::AppendBefore( TInt aLineNum, TDes& aLine )
{
CMenu::AppendBefore( aLineNum, aLine );
if( ( aLine.MaxLength() - aLine.Length() ) < 2 )
{
return;
}
if( iTestSets[aLineNum].Status() & CUIStoreIf::ESetRunning )
{
aLine.Append( _L("O ") );
}
else if( iTestSets[aLineNum].Status() & CUIStoreIf::ESetPassed )
{
aLine.Append( _L("P ") );
}
else if( iTestSets[aLineNum].Status() & CUIStoreIf::ESetFailed )
{
aLine.Append( _L("F ") );
}
}
/*
-------------------------------------------------------------------------------
Class: CStartedTestSetMenu
Method: SelectL
Description: Process keypresses in menu. Handle Enter and Right Arrow
here, other will be handled in CMenu::SelectL
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CStartedTestSetMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
switch (aSelection)
{
case EKeyEnter:
case EKeyRightArrow:
{
if ( iFirst + iPosOnScreen < iTestSets.Count() )
{
delete iCaseMenu;
iCaseMenu = 0;
iCaseMenu = CTestSetCaseMenu::NewL(
iMain,
this,
iTestSets[iFirst + iPosOnScreen].TestSetInfo().Name(),
iTestSets[iFirst + iPosOnScreen] );
return iCaseMenu;
}
}
return this;
default:
break;
}
// Let the parent class handle rest
return CMenu::SelectL(aSelection, aContinue);
}
/*
-------------------------------------------------------------------------------
Class: CTestSetCaseMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
TCaseState aType :in: Case state
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetCaseMenu* CTestSetCaseMenu::NewL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName,
CStartedTestSet& aTestSet )
{
CTestSetCaseMenu* self = new ( ELeave ) CTestSetCaseMenu( aTestSet );
CleanupStack::PushL( self );
self->ConstructL( aConsole, aParent, aName );
CleanupStack::Pop( self );
return self;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetCaseMenu
Method: CTestSetCaseMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetCaseMenu::CTestSetCaseMenu( CStartedTestSet& aTestSet ):
iTestSet( aTestSet )
{
}
/*
-------------------------------------------------------------------------------
Class: CTestSetCaseMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
TCaseState aType :in: Case state
Return Values: None
Errors/Exceptions: Leaves if parent class ConstructL leaves
Leaves if memory allocation fails
Leaves if CCaseOperation menu NewL leaves
Leaves if UpcateCaseListL leaves
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetCaseMenu::ConstructL( CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName )
{
CCaseMenu::ConstructL( aConsole, aParent, aName,
CUIStoreIf::EStatusAll );
}
/*
-------------------------------------------------------------------------------
Class: CTestSetCaseMenu
Method: ~CTestSetCaseMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CTestSetCaseMenu::~CTestSetCaseMenu()
{
}
/*
-------------------------------------------------------------------------------
Class: CTestSetCaseMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CTestSetCaseMenu::ItemTexts( RRefArray<TDesC>& aArray )
{
if ( iTestSet.Status() & CUIStoreIf::ESetRunning )
{
if( aArray.Append( KCancelTestSet ) != KErrNone )
{
return KErrNoMemory;
}
}
const RRefArray<CStartedTestCase>& testCases = iTestSet.TestCases();
iTestCases.Reset();
TInt count = testCases.Count();
for( TInt i=0; i<count; i++ )
{
if( iTestCases.Append( testCases[i] ) != KErrNone )
{
return KErrNoMemory;
}
if( aArray.Append( testCases[i].TestInfo().TestCaseTitle() ) != KErrNone )
{
return KErrNoMemory;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CTestSetCaseMenu
Method: AppendBefore
Description: Append text before line.
Parameters: TInt aLine: in: line number
TDes& aLine: in: line text
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CTestSetCaseMenu::AppendBefore( TInt aLineNum, TDes& aLine )
{
CMenu::AppendBefore( aLineNum, aLine );
TInt testCaseNum = aLineNum;
if( iTestSet.Status() & CUIStoreIf::ESetRunning )
{
if( aLineNum == 0 )
{
// "Cancel test set" row
return;
}
testCaseNum--;
}
if( ( aLine.MaxLength() - aLine.Length() ) < 2 )
{
return;
}
if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusRunning )
{
aLine.Append( _L("O ") );
}
else if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusPassed )
{
aLine.Append( _L("P ") );
}
else if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusFailed )
{
aLine.Append( _L("F ") );
}
else if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusAborted )
{
aLine.Append( _L("A ") );
}
else if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusCrashed )
{
aLine.Append( _L("C ") );
}
}
/*
-------------------------------------------------------------------------------
Class: CTestSetCaseMenu
Method: SelectL
Description: Process keypresses in menu. Handle enter and right arrow here,
others in CMenu::SelectL.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CTestSetCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue )
{
MapKeyCode(aSelection);
if( ( aSelection == EKeyEnter ) || ( aSelection == EKeyRightArrow ) )
{
TInt pos = iFirst + iPosOnScreen;
if( iTestSet.Status() & CUIStoreIf::ESetRunning )
{
pos--;
}
if( pos == -1 )
{
User::LeaveIfError(
iMain->UIStore().AbortTestSet( iTestSet ) );
return iParent;
}
else if( pos < iTestCases.Count() )
{
delete iCaseOperationMenu;
iCaseOperationMenu = 0;
iCaseOperationMenu = CCaseOperationMenu::NewL(
iMain,
this,
iTestCases[pos].TestInfo().TestCaseTitle(),
&iTestCases[pos] );
return iCaseOperationMenu;
}
}
// Let the parent class handle rest
return CMenu::SelectL(aSelection, aContinue);
}
/*
-------------------------------------------------------------------------------
Class: CFilterMenu
Method: NewL
Description: Constructs new menu.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: CMenu* New menu
Errors/Exceptions: Leaves if memory allocation fails
Leaves if ConstructL leaves.
Status: Draft
-------------------------------------------------------------------------------
*/
CFilterMenu* CFilterMenu::NewL(CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName)
{
CFilterMenu* self = new (ELeave) CFilterMenu();
CleanupStack::PushL(self);
self->ConstructL(aConsole, aParent, aName);
CleanupStack::Pop(self);
return self;
}
/*
-------------------------------------------------------------------------------
Class: CFilterMenu
Method: ConstructL
Description: Second level constructor.
Parameters: CConsoleMain* aConsole :in: Pointer to main console
CMenu* aParent :in: Parent menu
const TDesC& aName :in: Menu name
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CFilterMenu::ConstructL(CConsoleMain* aConsole,
CMenu* aParent,
const TDesC& aName
)
{
CMenu::ConstructL(aConsole, aParent, aName);
}
/*
-------------------------------------------------------------------------------
CFilterMenu
Method: CFilterMenu
Description: Constructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CFilterMenu::CFilterMenu()
{
}
/*
-------------------------------------------------------------------------------
CFilterMenu
Method: ~CFilterMenu
Description: Destructor
Parameters: None
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CFilterMenu::~CFilterMenu()
{
delete iTestCaseMenu;
}
/*
-------------------------------------------------------------------------------
Class: CFilterMenu
Method: ItemText
Description: Returns menu item text
Parameters: const TInt :in: Menu index
Return Values: const TDesC& Menu line text
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
TInt CFilterMenu::ItemTexts(RRefArray<TDesC>& aArray)
{
const RPointerArray<TDesC> &filters = iMain->GetFilterArray();
TInt ret;
TInt count = filters.Count();
for(TInt i = 0; i < count; i++)
{
ret = aArray.Append(*filters[i]);
if(ret != KErrNone)
{
return ret;
}
}
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CFilterMenu
Method: SelectL
Description: Process keypresses in menu. Handle enter and right arrow here,
others in CMenu::SelectL.
Parameters: TKeyCode aSelection :in: Key
TBool& aContinue :out: Has user pressed "Quit"
Return Values: CMenu* New menu
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
CMenu* CFilterMenu::SelectL(TKeyCode aSelection, TBool& aContinue)
{
const RPointerArray<TDesC> &filters = iMain->GetFilterArray();
MapKeyCode(aSelection);
switch ( aSelection )
{
case EKeyEnter:
case EKeyRightArrow:
{
// Start the case
if((iFirst + iPosOnScreen) < filters.Count())
{
// Show test cases menu
iMain->SetFilterIndex(iFirst + iPosOnScreen);
if(iTestCaseMenu)
{
return iTestCaseMenu;
}
else
{
RDebug::Print(_L("STIF: CFilterMenu::SelectL: test case menu is not set, however it should be"));
return this;
}
}
else
{
return this;
}
}
default:
return CMenu::SelectL( aSelection, aContinue);
}
}
/*
-------------------------------------------------------------------------------
Class: CFilterMenu
Method: SetTestCaseMenu
Description: Set pointer to test case menu, so it can be shown when user
selects filter.
This menu will be deleted along with the filter menu.
Parameters: CMenu* aTestCaseMenu :in: test case menu
Return Values: None
Errors/Exceptions: None
Status: Draft
-------------------------------------------------------------------------------
*/
void CFilterMenu::SetTestCaseMenu(CMenu* aTestCaseMenu)
{
if(iTestCaseMenu)
{
RDebug::Print(_L("STIF: CFilterMenu::SetTestCaseMenu: test case menu is already set!"));
delete iTestCaseMenu;
iTestCaseMenu = NULL;
}
iTestCaseMenu = aTestCaseMenu;
}
// End of File