/*

* Copyright (c) 2002 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: Implementation of CPhoneSettingsTestCSP class.

*

*/

// INCLUDE FILES

#include <StifTestModule.h>

#include <nwdefs.h>             

#include <etelmm.h> 

#include <PsetConstants.h>

#include "PhoneSettingsTest.hrh"

#include "PhoneSettingsTest.h"

#include "MPhoneSettingsTestMessageHandler.h"

#include "PhoneSettingsTestUtilities.h" 

#include "PhoneSettingsTestDefs.h"

#include "PhoneSettingsTestCSP.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::CPhoneSettingsTestCSP

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CPhoneSettingsTestCSP::CPhoneSettingsTestCSP(

    CPhoneSettingsTestParser& aPhoneSettingsTestParser,

    MPhoneSettingsTestMessageHandler& aPhoneSettingsTestMessageHandler ):

    iTestParser(aPhoneSettingsTestParser),

    iTestMessageHandler(aPhoneSettingsTestMessageHandler)

    {	

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CPhoneSettingsTestCSP::ConstructL()

    {    	

    } 

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CPhoneSettingsTestCSP* CPhoneSettingsTestCSP::NewL(

    CPhoneSettingsTestParser& aPhoneSettingsTestParser,

    MPhoneSettingsTestMessageHandler& aPhoneSettingsTestMessageHandler )

    {

    CPhoneSettingsTestCSP* self = new (ELeave) CPhoneSettingsTestCSP(

        aPhoneSettingsTestParser, aPhoneSettingsTestMessageHandler );     

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CPhoneSettingsTestCSP::~CPhoneSettingsTestCSP()

    {          		

    delete iPsetCustomerServiceProfile;     

    }

// ----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::WaitTimer

// ----------------------------------------------------------------------------

//

void CPhoneSettingsTestCSP::WaitTimer(TInt aWaitTime)

    {

    CPeriodic* timer = CPeriodic::NewL( CActive::EPriorityStandard );

    timer->Start( aWaitTime, aWaitTime, TCallBack( DoCallBackL, this ) );

    iWaitTimer.Start();

    delete timer;

    }

// ----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::DoCallBackL

// ----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::DoCallBackL(TAny* aAny)

    {

    // Can't call iWaitAny.AsyncStop() in static function

    REINTERPRET_CAST( CPhoneSettingsTestCSP*, aAny )->Stop();

    return KErrNone;

    }

// ----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::Stop

// ----------------------------------------------------------------------------

//

void CPhoneSettingsTestCSP::Stop()

    {

    iWaitTimer.AsyncStop();  

    }

// ----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::SetupL

// ----------------------------------------------------------------------------

//

void CPhoneSettingsTestCSP::SetupL()

    {

	iPsetCustomerServiceProfile = CPsetCustomerServiceProfile::NewL();

    iPsetCustomerServiceProfile->OpenCSProfileL(); 

    }

// ----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TearDownL

// ----------------------------------------------------------------------------

//

void CPhoneSettingsTestCSP::TearDownL()

    {

    delete iPsetCustomerServiceProfile;

    iPsetCustomerServiceProfile = NULL; 

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestCPsetCustomerServiceProfileConstructAndDestructL

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestCPsetCustomerServiceProfileConstructAndDestructL(

    TTestResult& aResult)

	{

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPConstructAndDestruct() );

	// Do tests here 

	CPsetCustomerServiceProfile * psetCustomerServiceProfile = 

	    CPsetCustomerServiceProfile::NewL();

	CleanupStack::PushL( psetCustomerServiceProfile ); 

	ASSERT( psetCustomerServiceProfile != NULL ); 

    // Uninitialize test             

    CleanupStack::PopAndDestroy( psetCustomerServiceProfile  ); 

	// Set result for STIF framework

	aResult.SetResult( KErrNone, KCSPConstructAndDestruct );	

    iTestMessageHandler.PrintMessage( KExitingTestCase() );    

	return KErrNone; 

	}

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestIsALSSupported

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestIsALSSupported(TTestResult& aResult)

    {

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPIsALSSupported() );

	// Initialize test 	

	SetupL(); 

    TBool alsSupport; 

	// Do tests here 

    iPsetCustomerServiceProfile->IsALSSupported( alsSupport ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

    // Parse result data     

    iTestParser.ParseTBool( alsSupport ); 

    // Uninitialize test             

	TearDownL(); 

	// Set result for STIF framework

	aResult.SetResult( KErrNone, KCSPIsALSSupported );

    iTestMessageHandler.PrintMessage( KExitingTestCase() );    

	return KErrNone;     

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestIsCBSupported

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestIsCBSupported(TTestResult& aResult)

    {

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPIsCBSupported() );

	// Initialize test 	

	SetupL(); 

    TBool cbsSupport; 

	// Do tests here 

    iPsetCustomerServiceProfile->IsCBSupported( cbsSupport ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

    // Parse result data     

    iTestParser.ParseTBool( cbsSupport ); 

    // Uninitialize test             

	TearDownL(); 

	// Set result for STIF framework

	aResult.SetResult( KErrNone, KCSPIsCBSupported );	

    iTestMessageHandler.PrintMessage( KExitingTestCase() );    

	return KErrNone;     

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestIsCFSupported

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestIsCFSupported(TTestResult& aResult)

    {

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPIsCFSupported() );

	// Initialize test 	

	SetupL(); 

    TBool cfSupport; 

	// Do tests here 

    iPsetCustomerServiceProfile->IsCFSupported( cfSupport ); 

    // Parse result data     

    iTestParser.ParseTBool( cfSupport );

    // Uninitialize test             

	TearDownL(); 

	// Set result for STIF framework

	aResult.SetResult( KErrNone, KCSPIsCFSupported );	

    iTestMessageHandler.PrintMessage( KExitingTestCase() );    

	return KErrNone;     

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestIsCWSupported

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestIsCWSupported(TTestResult& aResult)

    {

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPIsCWSupported() );

	// Initialize test 	

	SetupL(); 

    TBool cwSupport; 

	// Do tests here 

    iPsetCustomerServiceProfile->IsCWSupported( cwSupport );  

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

    // Parse result data     

    iTestParser.ParseTBool( cwSupport );

    // Uninitialize test             

	TearDownL(); 

	// Set result for STIF framework

	aResult.SetResult( KErrNone, KCSPIsCWSupported );	

    iTestMessageHandler.PrintMessage( KExitingTestCase() );    

	return KErrNone;     

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestIsNetworkSelectionSupported

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestIsNetworkSelectionSupported(TTestResult& aResult)

    {

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPIsNetworkSelectionSupported() );

	// Initialize test 	

	SetupL(); 

    TBool networkSelectionSupport; 

	// Do tests here 

    iPsetCustomerServiceProfile->IsNetworkSelectionSupported( networkSelectionSupport ); 

    // Parse result data     

    iTestParser.ParseTBool( networkSelectionSupport );

    // Uninitialize test             

	TearDownL(); 

	// Set result for STIF framework

	aResult.SetResult( KErrNone, KCSPIsNetworkSelectionSupported );

    iTestMessageHandler.PrintMessage( KExitingTestCase() );    

	return KErrNone;     

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestOpenCSProfileL

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestOpenCSProfileL(TTestResult& aResult)

    {

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPOpenCSProfileL() );

	// Initialize test 	

	SetupL(); 

	// Do tests here 

    TInt err = iPsetCustomerServiceProfile->OpenCSProfileL(); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

    // Uninitialize test             

	TearDownL(); 

	// Set result for STIF framework

	aResult.SetResult( err, KCSPOpenCSProfileL );	

    iTestMessageHandler.PrintMessage( KExitingTestCase() );    

	return KErrNone;     

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestCheckIfCWSupported

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestCheckIfCWSupported(TTestResult& aResult)

    {

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPCheckIfCWSupported() );

#ifndef PHONESETTINGSTEST_LIBRARY_ONLY

	// Initialize test 	

	SetupL(); 

    RMobilePhone::TCspCallCompletion cspCallCompletion; 

    TBool isCspCWSupported; 	

    TBool isCspCCBSSupported; 	

    TBool isCspHoldSupported; 	

	// Do tests here 

	cspCallCompletion = RMobilePhone::KCspCCBS; 	 

    isCspCCBSSupported = iPsetCustomerServiceProfile->CheckIfCWSupported( cspCallCompletion ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

	cspCallCompletion = RMobilePhone::KCspCW; 	 

    isCspCWSupported = iPsetCustomerServiceProfile->CheckIfCWSupported( cspCallCompletion ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );  

	cspCallCompletion = RMobilePhone::KCspHOLD; 	 

    isCspHoldSupported = iPsetCustomerServiceProfile->CheckIfCWSupported( cspCallCompletion ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

    // Parse result data 

    iTestMessageHandler.PrintMessage( KKCspCCBS() );

    iTestParser.ParseTBool( isCspCCBSSupported );     

    iTestMessageHandler.PrintMessage( KKCspCW() );

    iTestParser.ParseTBool( isCspCWSupported );     

    iTestMessageHandler.PrintMessage( KKCspHOLD() );

    iTestParser.ParseTBool( isCspHoldSupported ); 

    // Uninitialize test             

	TearDownL(); 

	// Set result for STIF framework

	aResult.SetResult( KErrNone, KCSPCheckIfCWSupported );	

#else // PHONESETTINGSTEST_LIBRARY_ONLY

	aResult.SetResult( KErrNotSupported, KCSPCheckIfCWSupported );	

#endif // PHONESETTINGSTEST_LIBRARY_ONLY	

    iTestMessageHandler.PrintMessage( KExitingTestCase() );    

	return KErrNone;     

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestCheckIfCBSupported

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestCheckIfCBSupported(TTestResult& aResult)

    {

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPCheckIfCBSupported() );

#ifndef PHONESETTINGSTEST_LIBRARY_ONLY

	// Initialize test 	

	SetupL(); 

    RMobilePhone::TCspCallRestriction callRestriction; 

    TBool isSupportedBICRoam; 

    TBool isSupportedBAIC; 

    TBool isSupportedBOICexHC; 

    TBool isSupportedBOIC; 

    TBool isSupportedBOAC; 

	// Do tests here 

	callRestriction = RMobilePhone::KCspBICRoam; 

    isSupportedBICRoam = iPsetCustomerServiceProfile->CheckIfCBSupported( callRestriction ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

	callRestriction = RMobilePhone::KCspBAIC; 

    isSupportedBAIC = iPsetCustomerServiceProfile->CheckIfCBSupported( callRestriction ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

	callRestriction = RMobilePhone::KCspBOICexHC; 

    isSupportedBOICexHC = iPsetCustomerServiceProfile->CheckIfCBSupported( callRestriction ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

	callRestriction = RMobilePhone::KCspBOIC; 

    isSupportedBOIC = iPsetCustomerServiceProfile->CheckIfCBSupported( callRestriction ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

	callRestriction = RMobilePhone::KCspBOAC; 

    isSupportedBOAC = iPsetCustomerServiceProfile->CheckIfCBSupported( callRestriction ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

    // Parse result data

    iTestMessageHandler.PrintMessage( KKCspBICRoam() );

    iTestParser.ParseTBool( isSupportedBICRoam ); 

    iTestMessageHandler.PrintMessage( KKCspBAIC() );

    iTestParser.ParseTBool( isSupportedBAIC ); 

    iTestMessageHandler.PrintMessage( KKCspBOICexHC() );

    iTestParser.ParseTBool( isSupportedBOICexHC ); 

    iTestMessageHandler.PrintMessage( KKCspBOIC() );

    iTestParser.ParseTBool( isSupportedBOIC ); 

    iTestMessageHandler.PrintMessage( KKCspBOAC() );

    iTestParser.ParseTBool( isSupportedBOAC ); 

    // Uninitialize test             

	TearDownL(); 

	// Set result for STIF framework

	aResult.SetResult( KErrNone, KCSPCheckIfCBSupported );		    

#else // PHONESETTINGSTEST_LIBRARY_ONLY	

	aResult.SetResult( KErrNotSupported, KCSPCheckIfCBSupported );		    

#endif // PHONESETTINGSTEST_LIBRARY_ONLY

    iTestMessageHandler.PrintMessage( KExitingTestCase() );    

	return KErrNone;     

    }

// -----------------------------------------------------------------------------

// CPhoneSettingsTestCSP::TestCheckIfCFSupported

// 

// -----------------------------------------------------------------------------

//

TInt CPhoneSettingsTestCSP::TestCheckIfCFSupported(TTestResult& aResult)

    {

	iTestMessageHandler.PrintMessage( KStartingTestCase() );

	iTestMessageHandler.PrintMessage( KCSPCheckIfCFSupported() );

#ifndef PHONESETTINGSTEST_LIBRARY_ONLY

	// Initialize test 	

	SetupL(); 

    RMobilePhone::TCspCallOffering callOffering; 

    TBool isSupportedCFU; 

    TBool isSupportedCFB; 

    TBool isSupportedCFNRc; 

    TBool isSupportedCFNRy; 

	// Do tests here 

	callOffering = RMobilePhone::KCspCFU; 

    isSupportedCFU = iPsetCustomerServiceProfile->CheckIfCFSupported( callOffering ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

	callOffering = RMobilePhone::KCspCFB; 

    isSupportedCFB = iPsetCustomerServiceProfile->CheckIfCFSupported( callOffering ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

	callOffering = RMobilePhone::KCspCFNRc; 

    isSupportedCFNRc = iPsetCustomerServiceProfile->CheckIfCFSupported( callOffering ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

	callOffering = RMobilePhone::KCspCFNRy; 

    isSupportedCFNRy = iPsetCustomerServiceProfile->CheckIfCFSupported( callOffering ); 

    WaitTimer( KPhoneSettingsTestAsyncTimeout );   

    // Parse result data

    iTestMessageHandler.PrintMessage( KKCspCFU() );

    iTestParser.ParseTBool( isSupportedCFU ); 

    iTestMessageHandler.PrintMessage( KKCspCFB() );

    iTestParser.ParseTBool( isSupportedCFB ); 

    iTestMessageHandler.PrintMessage( KKCspCFNRc() );

    iTestParser.ParseTBool( isSupportedCFNRc ); 

    iTestMessageHandler.PrintMessage( KKCspCFNRy() );

    iTestParser.ParseTBool( isSupportedCFNRy ); 

    // Uninitialize test             

	TearDownL(); 

	// Set result for STIF framework