/*
* 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: For packing VMBXEngine test component.
*
*/
// INCLUDE FILES
#include <stiftestinterface.h>
#include <stifparser.h>
#include <e32math.h>
#include <centralrepository.h>
#include <cenrepnotifyhandler.h>
#include "vmnumber.h"
#include "vmbxenginetest.h"
// ======== MEMBER FUNCTIONS ========
const TUid KUidVoiceMailbox = {0x101F874F};
const TUint32 KVmUIKeyOpts = 0x00000010;
const TInt KVmUIKeyOptsForSimOnly = 1;
const TInt KVmDefaultUIKeyOpts = 0;
// ---------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
CVmbxEngineTest::CVmbxEngineTest( CTestModuleIf& aTestModuleIf ) :
CScriptBase( aTestModuleIf ), iSession( NULL ), iNotifyHandler( NULL )
{
}
// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CVmbxEngineTest::ConstructL()
{
// Constructing static buffer size logger, needed with OOM testing because
// normally logger allocates memory from heap!
iLog = CStifLogger::NewL( KLogPath,
KLogFile,
CStifLogger::ETxt,
CStifLogger::EFile,
EFalse,
ETrue,
ETrue,
EFalse,
ETrue,
EFalse,
100 );
iLog->Log( _L( "CVmbxEngineTest logging starts!" ) );
}
// ---------------------------------------------------------------------------
// NewL creates a new test module
// ---------------------------------------------------------------------------
//
CVmbxEngineTest* CVmbxEngineTest::NewL( CTestModuleIf& aTestModuleIf )
{
CVmbxEngineTest* self = new ( ELeave ) CVmbxEngineTest( aTestModuleIf );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop();
return self;
}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CVmbxEngineTest::~CVmbxEngineTest()
{
if ( iLog )
{
iLog->Log( _L( "###### TEST MODULE CLOSED #######" ) );
delete iLog;
}
delete iVmbxNumber;
if ( iNotifyHandler )
{
iNotifyHandler->StopListening();
delete iNotifyHandler;
}
delete iSession;
delete iNumberBuf;
}
// ---------------------------------------------------------------------------
// From class CScriptBase.
// Runs a script line
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::RunMethodL( CStifItemParser& aItem )
{
static TStifFunctionInfo const KFunctions[] =
{
ENTRY( "Connect", CVmbxEngineTest::Connect ),
ENTRY( "Close", CVmbxEngineTest::Close ),
// test RVmbxNumber APIs
ENTRY( "AllowedToChangeTheNumber",
CVmbxEngineTest::AllowedToChangeTheNumber ),
ENTRY( "SelectTypeL", CVmbxEngineTest::SelectTypeL ),
ENTRY( "IsSimMemory", CVmbxEngineTest::IsSimMemory ),
ENTRY( "QueryVideoMbxNumber", CVmbxEngineTest::QueryVideoMbxNumber ),
ENTRY( "QueryNumberL", CVmbxEngineTest::QueryNumberL ),
ENTRY( "GetVideoMbxNumber", CVmbxEngineTest::GetVideoMbxNumber ),
ENTRY( "ConfCenRepForEditNotAllowedL",
CVmbxEngineTest::ConfCenRepForEditNotAllowedL ),
ENTRY( "RevertCenRepEditNotAllowedL",
CVmbxEngineTest::RevertCenRepEditNotAllowedL ),
ENTRY( "ConfCenRepForEditAllowedL",
CVmbxEngineTest::ConfCenRepForEditAllowedL ),
ENTRY( "InitGetNumFromSpecialMem",
CVmbxEngineTest::InitGetNumFromSpecialMem ),
ENTRY( "TestGetNumFromSpecialMem",
CVmbxEngineTest::TestGetNumFromSpecialMem ),
ENTRY( "CleanupGetNumFromSpecialMem",
CVmbxEngineTest::CleanupGetNumFromSpecialMem )
};
const TInt count = sizeof( KFunctions ) /
sizeof( TStifFunctionInfo );
return RunInternalL( KFunctions, count, aItem );
}
// ---------------------------------------------------------------------------
// Calls CVmbxEngineTest::Connect method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::Connect( CStifItemParser& /*aItem*/ )
{
TInt error = KErrAlreadyExists;
if ( !iVmbxNumber )
{
iVmbxNumber = new RVmbxNumber();
if ( iVmbxNumber )
{
iLog->Log( _L( "Opening.." ) );
error = iVmbxNumber->Open();
if ( KErrNone == error )
{
// save the source number temporarily
// so that it will be used while some cases are reverted.
SaveSourceNumber();
}
}
}
iLog->Log( _L( "Connecting done, %d" ), error );
return error;
}
// ---------------------------------------------------------------------------
// Calls CVmbxEngineTest::Close method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::Close( CStifItemParser& /*aItem*/ )
{
iLog->Log( _L( "Closing.." ) );
if ( iVmbxNumber )
{
iVmbxNumber->Close();
delete iVmbxNumber;
iVmbxNumber = NULL;
if ( iNumberBuf )
{
delete iNumberBuf;
iNumberBuf = NULL;
}
}
return KErrNone;
}
// ---------------------------------------------------------------------------
// CVmbxEngineTest::AllowedToChangeTheNumber method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::AllowedToChangeTheNumber( CStifItemParser& /*aItem*/ )
{
TInt result( KErrNone );
result = iVmbxNumber->AllowedToChangeTheNumber();
iLog->Log( _L( "AllowedToChangeTheNumber return %d" ), result);
return result;
}
// ---------------------------------------------------------------------------
// CVmbxEngineTest::SelectTypeL method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::SelectTypeL( CStifItemParser& /*aItem*/ )
{
TInt result( KErrNone );
TRAP( result, iVmbxNumber->SelectTypeL( EVmbxDefine ) );
iLog->Log( _L( "SelectTypeL return result %d" ), result );
return result;
}
// ---------------------------------------------------------------------------
// CVmbxEngineTest::IsSimMemory method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::IsSimMemory( CStifItemParser& /*aItem*/ )
{
// Use allownextresult keyword in config file to control what is expected
// return value in your test case.
TInt result( KErrNone );
result = iVmbxNumber->IsSimMemory();
iLog->Log( _L( "IsSimMemory return %d" ), result );
return result;
}
// ---------------------------------------------------------------------------
// CVmbxEngineTest::QueryVideoMbxNumber method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::QueryVideoMbxNumber( CStifItemParser& aItem )
{
// Use allownextresult keyword in config file to control what is expected
// return value in your test case.
TInt result( KErrNone );
TBuf< KVmbxMaxNumberLength > number;
TInt queryType( KErrNone );
aItem.GetNextInt( queryType );
TRAP( result, iVmbxNumber->QueryVideoMbxNumberL(
( TVmbxQueryType )queryType, number ) );
iLog->Log( _L( "QueryVideoMbxNumber return %d" ), result );
return result;
}
// ---------------------------------------------------------------------------
// CVmbxEngineTest::QueryNumberL method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::QueryNumberL( CStifItemParser& aItem )
{
// Use allownextresult keyword in config file to control what is expected
// return value in your test case.
TInt result( KErrNone );
TBuf< KVmbxMaxNumberLength > number;
TInt queryType( KErrNone );
aItem.GetNextInt( queryType );
TRAP( result, iVmbxNumber->QueryNumberL( ( TVmbxQueryType )queryType,
number, EFalse ) );
iLog->Log( _L( "QueryNumberL return %d" ), result );
return result;
}
// ---------------------------------------------------------------------------
// CVmbxEngineTest::GetVideoMbxNumber method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::GetVideoMbxNumber( CStifItemParser& /*aItem*/ )
{
// Use allownextresult keyword in config file to control what is expected
// return value in your test case.
TInt result( KErrNone );
TBuf< KVmbxMaxNumberLength > number;
result = iVmbxNumber->GetVideoMbxNumber( number );
iLog->Log( _L( "GetVideoMbxNumber return %d" ), result );
return result;
}
// ---------------------------------------------------------------------------
// Calls CVmbxEngineTest::ConfCenRepForEditNotAllowedL method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::ConfCenRepForEditNotAllowedL( CStifItemParser& /*aItem*/ )
{
TInt ret( KErrNone );
// create central repository for session and handler
CreateCentralRepositoryL();
// configurate the key for the special condition like "sim only"
ret = iSession->Set( KVmUIKeyOpts, KVmUIKeyOptsForSimOnly );
iLog->Log( _L( "ConfCenRepForEditNotAllowedL %d" ), ret );
return ret;
}
// ---------------------------------------------------------------------------
// Calls CVmbxEngineTest::RevertCenRepEditNotAllowedL method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::RevertCenRepEditNotAllowedL( CStifItemParser& /*aItem*/ )
{
TInt ret( KErrNone );
// reset the key to default value
ret = iSession->Set( KVmUIKeyOpts, KVmDefaultUIKeyOpts );
iLog->Log( _L( "RevertCenRepEditNotAllowedL %d" ), ret );
return ret;
}
// ---------------------------------------------------------------------------
// Calls CVmbxEngineTest::ConfCenRepForEditAllowedL method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::ConfCenRepForEditAllowedL( CStifItemParser& /*aItem*/ )
{
TInt ret( KErrNone );
// create central repository for session and handler
CreateCentralRepositoryL();
// configurate the key for the special condition like "sim only"
ret = iSession->Set( KVmUIKeyOpts, KVmDefaultUIKeyOpts );
iLog->Log( _L( "ConfCenRepForEditAllowedL %d" ), ret );
return ret;
}
// ---------------------------------------------------------------------------
// Calls CVmbxEngineTest::InitGetNumFromSpecialMem method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::InitGetNumFromSpecialMem( CStifItemParser& aItem )
{
TInt ret( KErrNone );
// Get number from Script file
TPtrC numberFromScript;
aItem.GetNextString( numberFromScript );
iLog->Log( _L( "InitGetNumFromSpecialMem saving number %S" ),
&numberFromScript );
// the number need to be saved to the sim/phone memory
// to init the special case
ret = iVmbxNumber->SaveVmbxNumber( numberFromScript,
EAlsActiveLineEntry );
iLog->Log( _L( "InitGetNumFromSpecialMem return %d" ), ret );
return ret;
}
// ---------------------------------------------------------------------------
// Calls CVmbxEngineTest::TestGetNumFromSpecialMem method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::TestGetNumFromSpecialMem( CStifItemParser& aItem )
{
TInt ret( KErrNotFound );
TBuf< KVmbxMaxNumberLength > number;
// Use allownextresult keyword in config file to control what is expected
// return value in your test case.
TPtrC numberFromScript;
aItem.GetNextString( numberFromScript );
iLog->Log( _L( "TestGetNumFromSpecialMem saving number %S" ),
&numberFromScript );
ret = iVmbxNumber->GetVmbxNumber( number );
if ( KErrNone == ret && KErrNone == number.Compare( numberFromScript ) )
{
ret = KErrNone;
}
iLog->Log( _L( "TestGetNumFromSpecialMem number %S" ), &number );
iLog->Log( _L( "TestGetNumFromSpecialMem return %d" ), ret );
return ret;
}
// ---------------------------------------------------------------------------
// Calls CVmbxEngineTest::CleanupGetNumFromSpecialMem method
// ---------------------------------------------------------------------------
//
TInt CVmbxEngineTest::CleanupGetNumFromSpecialMem( CStifItemParser& /*aItem*/ )
{
TInt ret( KErrNone );
// revert the source number to sim/phone memory
ret = iVmbxNumber->SaveVmbxNumber( *iNumberBuf,
EAlsActiveLineEntry );
iLog->Log( _L( "CleanupGetNumFromSpecialMem return %d" ), ret );
return ret;
}
// ---------------------------------------------------------------------------
// Save the source number temporarily
// ---------------------------------------------------------------------------
//
void CVmbxEngineTest::SaveSourceNumber()
{
iNumberBuf = HBufC::New( KVmbxMaxNumberLength );
if ( iNumberBuf )
{
TPtr ptr( iNumberBuf->Des() );
iVmbxNumber->GetVmbxNumber( ptr );
}
}
// ---------------------------------------------------------------------------
// Create central repository for session and handler
// ---------------------------------------------------------------------------
//
void CVmbxEngineTest::CreateCentralRepositoryL()
{
if ( !iSession )
{
// create central repository
iSession = CRepository::NewL( KUidVoiceMailbox );
}
if ( !iNotifyHandler )
{
// set notify handler, when the key had been changed
// in the whole repository
iNotifyHandler = CCenRepNotifyHandler::NewL( *this, *iSession );
if ( iNotifyHandler )
{
iNotifyHandler->StartListeningL();
}
}
}
// ======== GLOBAL FUNCTIONS ========
// -----------------------------------------------------------------------------
// LibEntryL is a polymorphic Dll entry point
// Returns: CScriptBase*: Pointer to Test Module object
// -----------------------------------------------------------------------------
//
EXPORT_C CScriptBase* LibEntryL( CTestModuleIf& aTestModuleIf )
{
return CVmbxEngineTest::NewL( aTestModuleIf );
}