/*
* Copyright (c) 2010 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 file contains Hardcoded module implementation.
*
*/
#include <Stiftestinterface.h>
#include <SettingServerClient.h>
#include <sifui.h> // CSifUi
#include "SifUiTest.h"
const TInt KTestStackSize = 0x8000; // 32K stack
const TInt KTestMinHeap = 0x4000; // 16K heap min
const TInt KTestMaxHeap = 0x200000; // 2M heap max
// ======== MEMBER FUNCTIONS ========
// -----------------------------------------------------------------------------
// CSifUiTest::NewL()
// -----------------------------------------------------------------------------
//
CSifUiTest* CSifUiTest::NewL()
{
CSifUiTest* self = new (ELeave) CSifUiTest;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
// -----------------------------------------------------------------------------
// CSifUiTest::~CSifUiTest()
// -----------------------------------------------------------------------------
//
CSifUiTest::~CSifUiTest()
{
iLog = NULL;
delete iStdLog;
delete iTCLog;
iFs.Close();
if( iScheduler )
{
CActiveScheduler::Install( NULL );
delete iScheduler;
}
}
// -----------------------------------------------------------------------------
// CSifUiTest::InitL()
// -----------------------------------------------------------------------------
//
TInt CSifUiTest::InitL( TFileName& /*aIniFile*/, TBool /*aFirstTime*/ )
{
return KErrNone;
}
// -----------------------------------------------------------------------------
// CSifUiTest::GetTestCasesL()
// -----------------------------------------------------------------------------
//
TInt CSifUiTest::GetTestCasesL( const TFileName& /*aConfig*/,
RPointerArray<TTestCaseInfo>& aTestCases )
{
for( TInt index = 0; Case( index ).iMethod != NULL; ++index )
{
TTestCaseInfo* newCase = new( ELeave ) TTestCaseInfo();
CleanupStack::PushL( newCase );
newCase->iCaseNumber = index;
newCase->iTitle.Copy( Case(index).iCaseName );
aTestCases.AppendL( newCase );
CleanupStack::Pop( newCase );
}
return KErrNone;
}
// -----------------------------------------------------------------------------
// CSifUiTest::RunTestCaseL
// -----------------------------------------------------------------------------
//
TInt CSifUiTest::RunTestCaseL( const TInt aCaseNumber,
const TFileName& /*aConfig*/, TTestResult& aResult )
{
if( !iVersionLogged )
{
SendTestModuleVersion();
iVersionLogged = ETrue;
}
TInt returnValue = KErrNone;
TCaseInfo caseInfo = Case ( aCaseNumber );
if( caseInfo.iMethod != NULL )
{
_LIT( KLogStartTC, "Starting testcase [%S]" );
iLog->Log( KLogStartTC, &caseInfo.iCaseName );
// Switch to use test case (TC) logger if necessary
if( iAddTestCaseTitleToLogName )
{
if( iTCLog )
{
delete iTCLog;
iTCLog = NULL;
}
TName title;
TestModuleIf().GetTestCaseTitleL( title );
TFileName logFileName;
logFileName.Format( KSifUiTestLogFileWithTitle, &title );
iTCLog = CStifLogger::NewL( KSifUiTestLogPath, logFileName );
iLog = iTCLog;
}
// Run test case
iMethod = caseInfo.iMethod;
TRAPD( err, returnValue = ( this->*iMethod )( aResult ) );
// Restore standard log and close test case logger
if( iAddTestCaseTitleToLogName )
{
iLog = iStdLog;
delete iTCLog;
iTCLog = NULL;
}
// Leave if the case execution failed
User::LeaveIfError( err );
}
else
{
returnValue = KErrNotFound;
}
// Return case execution status (not the result of the case execution)
return returnValue;
}
//-----------------------------------------------------------------------------
// CSifUiTest::SendTestModuleVersion
//-----------------------------------------------------------------------------
//
void CSifUiTest::SendTestModuleVersion()
{
TVersion moduleVersion;
moduleVersion.iMajor = TEST_MODULE_VERSION_MAJOR;
moduleVersion.iMinor = TEST_MODULE_VERSION_MINOR;
moduleVersion.iBuild = TEST_MODULE_VERSION_BUILD;
TFileName moduleName;
moduleName = _L("SifUiTest.dll");
TBool newVersionOfMethod = ETrue;
TestModuleIf().SendTestModuleVersion( moduleVersion, moduleName, newVersionOfMethod );
}
// -----------------------------------------------------------------------------
// CSifUiTest::CSifUiTest()
// -----------------------------------------------------------------------------
//
CSifUiTest::CSifUiTest()
{
}
// -----------------------------------------------------------------------------
// CSifUiTest::ConstructL()
// -----------------------------------------------------------------------------
//
void CSifUiTest::ConstructL()
{
User::LeaveIfError( iFs.Connect() );
RSettingServer settingsServer;
User::LeaveIfError( settingsServer.Connect() );
CleanupClosePushL( settingsServer );
TLoggerSettings loggerSettings;
User::LeaveIfError( settingsServer.GetLoggerSettings( loggerSettings ) );
CleanupStack::PopAndDestroy( &settingsServer );
iAddTestCaseTitleToLogName = loggerSettings.iAddTestCaseTitle;
iStdLog = CStifLogger::NewL( KSifUiTestLogPath, KSifUiTestLogFile );
iLog = iStdLog;
_LIT( KLogStart, "SifUiTest starts" );
iLog->Log( KLogStart );
iVersionLogged = EFalse;
if( !CActiveScheduler::Current() )
{
iScheduler = new( ELeave ) CActiveScheduler;
CActiveScheduler::Install( iScheduler );
}
}
// -----------------------------------------------------------------------------
// CSifUiTest::ErrorCodeString()
// -----------------------------------------------------------------------------
//
TPtrC CSifUiTest::ErrorCodeString( TInt aErrorCode ) const
{
switch( aErrorCode )
{
case KErrNone:
return _L("KErrNone");
case KErrNotFound:
return _L("KErrNotFound");
case KErrGeneral:
return _L("KErrGeneral");
case KErrCancel:
return _L("KErrCancel");
case KErrNoMemory:
return _L("KErrNoMemory");
case KErrNotSupported:
return _L("KErrNotSupported");
case KErrArgument:
return _L("KErrArgument");
case KErrTotalLossOfPrecision:
return _L("KErrTotalLossOfPrecision");
case KErrBadHandle:
return _L("KErrBadHandle");
case KErrOverflow:
return _L("KErrOverflow");
case KErrUnderflow:
return _L("KErrUnderflow");
case KErrAlreadyExists:
return _L("KErrAlreadyExists");
case KErrPathNotFound:
return _L("KErrPathNotFound");
case KErrDied:
return _L("KErrDied");
case KErrInUse:
return _L("KErrInUse");
case KErrServerTerminated:
return _L("KErrServerTerminated");
case KErrServerBusy:
return _L("KErrServerBusy");
case KErrCompletion:
return _L("KErrCompletion");
case KErrNotReady:
return _L("KErrNotReady");
case KErrUnknown:
return _L("KErrUnknown");
case KErrCorrupt:
return _L("KErrCorrupt");
case KErrAccessDenied:
return _L("KErrAccessDenied");
case KErrLocked:
return _L("KErrLocked");
case KErrWrite:
return _L("KErrWrite");
case KErrDisMounted:
return _L("KErrDisMounted");
case KErrEof:
return _L("KErrEof");
case KErrDiskFull:
return _L("KErrDiskFull");
case KErrBadDriver:
return _L("KErrBadDriver");
case KErrBadName:
return _L("KErrBadName");
case KErrCommsLineFail:
return _L("KErrCommsLineFail");
case KErrCommsFrame:
return _L("KErrCommsFrame");
case KErrCommsOverrun:
return _L("KErrCommsOverrun");
case KErrCommsParity:
return _L("KErrCommsParity");
case KErrTimedOut:
return _L("KErrTimedOut");
case KErrCouldNotConnect:
return _L("KErrCouldNotConnect");
case KErrCouldNotDisconnect:
return _L("KErrCouldNotDisconnect");
case KErrDisconnected:
return _L("KErrDisconnected");
case KErrBadLibraryEntryPoint:
return _L("KErrBadLibraryEntryPoint");
case KErrBadDescriptor:
return _L("KErrBadDescriptor");
case KErrAbort:
return _L("KErrAbort");
case KErrTooBig:
return _L("KErrTooBig");
case KErrDivideByZero:
return _L("KErrDivideByZero");
case KErrBadPower:
return _L("KErrBadPower");
case KErrDirFull:
return _L("KErrDirFull");
case KErrHardwareNotAvailable:
return _L("KErrHardwareNotAvailable");
case KErrSessionClosed:
return _L("KErrSessionClosed");
case KErrPermissionDenied:
return _L("KErrPermissionDenied");
case KErrExtensionNotSupported:
return _L("KErrExtensionNotSupported");
case KErrCommsBreak:
return _L("KErrCommsBreak");
case KErrNoSecureTime:
return _L("KErrNoSecureTime");
}
return _L("UNKNOWN ERROR CODE");
}
// -----------------------------------------------------------------------------
// CSifUiTest::SetResult()
// -----------------------------------------------------------------------------
//
void CSifUiTest::SetResult( TTestResult& aResult, const TInt aReturnCode ) const
{
aResult.SetResult( aReturnCode, ErrorCodeString( aReturnCode ) );
}
// ==== OTHER EXPORTED FUNCTIONS ====
// -----------------------------------------------------------------------------
// LibEntryL is a polymorphic Dll entry point
// -----------------------------------------------------------------------------
//
EXPORT_C CTestModuleBase* LibEntryL()
{
return CSifUiTest::NewL();
}
// -----------------------------------------------------------------------------
// SetRequirements handles test module parameters
// -----------------------------------------------------------------------------
//
EXPORT_C TInt SetRequirements( CTestModuleParam*& aTestModuleParam,
TUint32& aParameterValid )
{
aParameterValid = KStifTestModuleParameterChanged;
CTestModuleParamVer01* param = NULL;
TRAPD( error, param = CTestModuleParamVer01::NewL() );
if( !error )
{
param->iTestThreadStackSize = KTestStackSize;
param->iTestThreadMinHeap = KTestMinHeap;
param->iTestThreadMaxHeap = KTestMaxHeap;
aTestModuleParam = param;
}
return error;
}