// Copyright (c) 2007-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:

// Test step definitions for the MultiBearerInteroperability functional unit.

// 

//

/**

 @internalTechnology

*/

#include <etelpckt.h>

#include <ctsy/rmmcustomapi.h>

#include <pcktcs.h>

#include "cctsyinidata.h" 

#include "cctsyintegrationtestmultibearerinteroperability.h"

#include "chttpdownload.h"

CCTSYIntegrationTestMultiBearerInteroperabilityBase::CCTSYIntegrationTestMultiBearerInteroperabilityBase(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr),

		iNetworkTestHelper(*this),

		iPacketServiceTestHelper(*this),

		iCallControlTestHelper(*this),

		iSmsStoreTsyTestHelper(*this)

/**

 * Constructor

 */

	{

	}

CCTSYIntegrationTestMultiBearerInteroperabilityBase::~CCTSYIntegrationTestMultiBearerInteroperabilityBase()

/*

 * Destructor

 */

	{

	}

void CCTSYIntegrationTestMultiBearerInteroperabilityBase::SetAttachModeToWhenPossibleAndWaitForAttachL(RPacketService& aPacketService)

/**

 * Attaches the phone to the packet service by setting the

 * attach mode to RPacketService::EAttachWhenPossible. Requests

 * that the phone attaches to the packet service and waits for

 * attach to complete.

 * 

 * @param aPacketService Reference to packet service subsession.

 *

 * @return void

 *

 */

    {

    RPacketService::TAttachMode attachMode;

    CHECK_EQUALS_L(aPacketService.GetAttachMode(attachMode), KErrNone, _L("RPacketService::GetAttachMode returned with an error."));

    TExtEtelRequestStatus notifyServiceStatusChStatus(aPacketService, EPacketNotifyStatusChange);

    CleanupStack::PushL(notifyServiceStatusChStatus);

    RPacketService::TStatus packetServiceStatus;

    aPacketService.NotifyStatusChange(notifyServiceStatusChStatus, packetServiceStatus);

    if(attachMode != RPacketService::EAttachWhenPossible)

		{

		CHECK_EQUALS_L(aPacketService.SetAttachMode(RPacketService::EAttachWhenPossible), KErrNone, _L("RPacketService::SetAttachMode returned with an error."));

		}

    CHECK_EQUALS_L(aPacketService.GetAttachMode(attachMode), KErrNone, _L("RPacketService::GetAttachMode returned with an error."));

    CHECK_EQUALS_L(attachMode, RPacketService::EAttachWhenPossible, _L("RPacketService::GetAttachMode did not return EAttachWhenPossible."));

    // Ensure phone is attached to the packet service (RPacketService::GetStatus returns EStatusAttached).

	RPacketService::TStatus packetStatus;

	CHECK_EQUALS_L(aPacketService.GetStatus(packetStatus), KErrNone, _L("RPacketService::GetStatus returned with an error"));

	// Wait for phone to attach to packet service if it is not attached.

	if (packetStatus == RPacketService::EStatusUnattached)

		{

        iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(

				aPacketService,

				notifyServiceStatusChStatus,

				packetServiceStatus, 

				RPacketService::EStatusAttached,

				KErrNone);

        CHECK_EQUALS_L(aPacketService.GetStatus(packetStatus), KErrNone, _L("RPacketService::GetStatus returned with an error"));

        CHECK_EQUALS_L(packetStatus, RPacketService::EStatusAttached, _L("RPacketService::GetStatus did not return EStatusAttached"));

		}

    // Pop

    // notifyServiceStatusChStatus

    CleanupStack::PopAndDestroy(1, &notifyServiceStatusChStatus);

    }

CCTSYIntegrationTestMultiBearerInteroperability0001::CCTSYIntegrationTestMultiBearerInteroperability0001(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestMultiBearerInteroperabilityBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestMultiBearerInteroperability0001::GetTestStepName());

	}

CCTSYIntegrationTestMultiBearerInteroperability0001::~CCTSYIntegrationTestMultiBearerInteroperability0001()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestMultiBearerInteroperability0001::doTestStepL()

/**

 * @SYMTestCaseID BA-CTSY-INT-MBI-0001

 * @SYMFssID BA/CTSY/MBI-0001

 * @SYMTestCaseDesc Verify simultaneous PS connection and MO CS call

 * @SYMTestPriority High

 * @SYMTestActions RLine::NotifyStatusChange, RCall::HangUp, RPacketContext::Activate, RPacketContext::NotifyStatusChange, RPacketService::NotifyStatusChange, RMobileSmsMessaging::SendMessage

 * @SYMTestExpectedResults Pass - MO call made.

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

 * Reason for test:

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

	// Ensure phone is camped on a valid cell. 

	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer,KMainPhone);

	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

	// Ensure phone is attached to packet service. 

	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer, KMainPhone, KMainPacketService);

	// Get voice line 1. 

	RMobileLine& mobileLine= iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

	// Get call 1. 

	RMobileCall& mobileCall= iEtelSessionMgr.GetCallL(KMainServer,KMainPhone, KVoiceLine, KCall1);

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// Post a notifier for RLine::NotifyStatusChange

	TCoreEtelRequestStatus<RLine> notifyLineChangeStatus (mobileLine, &RLine::NotifyStatusChangeCancel);

	CleanupStack::PushL(notifyLineChangeStatus);

	RCall::TStatus lineStatus;

	mobileLine.NotifyStatusChange(notifyLineChangeStatus,lineStatus);

	// Dial a number that answers. 

	TPtrC number;

	ASSERT_TRUE(GetStringFromConfig(KIniVoiceNumSection, KIniVoiceNumber1, number) != EFalse, _L("GetStringFromConfig did not complete as expected"));

	TCoreEtelRequestStatus<RMobileCall> dialStatus(mobileCall, &RMobileCall::DialCancel);

	CleanupStack::PushL(dialStatus);

	mobileCall.Dial(dialStatus, number);	

    ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::Dial timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::Dial returned error."));

	// Verify line rings and call is answered.

	RCall::TStatus expectedLineStatus = RCall::EStatusDialling;

	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

														 notifyLineChangeStatus,

														 lineStatus,

														 expectedLineStatus,

													     KErrNone);

    expectedLineStatus = RCall::EStatusConnecting;

	mobileLine.NotifyStatusChange(notifyLineChangeStatus,lineStatus);

	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

														 notifyLineChangeStatus,

														 lineStatus,

														 expectedLineStatus,

														 KErrNone);

    expectedLineStatus = RCall::EStatusConnected;

	mobileLine.NotifyStatusChange(notifyLineChangeStatus,lineStatus);

	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

														 notifyLineChangeStatus,

														 lineStatus,

														 expectedLineStatus,

														 KErrNone);

	// Hang up call. 

	TCoreEtelRequestStatus<RMobileCall> hangUpStatus (mobileCall, &RMobileCall::HangUpCancel);	

	CleanupStack::PushL(hangUpStatus);

	mobileCall.HangUp(hangUpStatus);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(hangUpStatus, ETimeMedium), KErrNone, _L("RMobileCall::HangUp timed-out"));

	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RMobileCall::CallHangUp returned an error"));

	// Activate a PDP context. 

	RPacketContext& packetContext = iEtelSessionMgr.GetPrimaryPacketContextL(KMainServer, KMainPhone, KMainPacketService, KPrimaryPacketContext1);

	iPacketServiceTestHelper.ActivatePrimaryPacketContextL(phone, packetContext);

    // Repost notifier for RLine::NotifyStatusChange

	mobileLine.NotifyStatusChange(notifyLineChangeStatus,lineStatus);

	// Post notification for service's status change

	RPacketService::TStatus packetServiceStatus;

	TExtEtelRequestStatus notifyServiceStatusChange(packetService, EPacketNotifyStatusChange);

	CleanupStack::PushL(notifyServiceStatusChange);

	packetService.NotifyStatusChange(notifyServiceStatusChange, packetServiceStatus);

	// Post notification for context's status change

	RPacketContext::TContextStatus packetContextStatus;

	TExtEtelRequestStatus notifyContextStatusChange(packetContext, EPacketContextNotifyStatusChange);

	CleanupStack::PushL(notifyContextStatusChange);

	packetContext.NotifyStatusChange(notifyContextStatusChange, packetContextStatus);

	// Dial a number that answers. 

	mobileCall.Dial(dialStatus, number);

	// Verify line rings and call is answered.

	expectedLineStatus = RCall::EStatusDialling;

	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

														 notifyLineChangeStatus,

														 lineStatus,

														 expectedLineStatus,

													     KErrNone);

    expectedLineStatus = RCall::EStatusConnecting;

	mobileLine.NotifyStatusChange(notifyLineChangeStatus,lineStatus);

	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

														 notifyLineChangeStatus,

														 lineStatus,

														 expectedLineStatus,

														 KErrNone);

	expectedLineStatus = RCall::EStatusConnected;

	mobileLine.NotifyStatusChange(notifyLineChangeStatus,lineStatus);

	iCallControlTestHelper.WaitForLineNotifyStatusChange(mobileLine,

														 notifyLineChangeStatus,

														 lineStatus,

														 expectedLineStatus,

														 KErrNone);

    ASSERT_EQUALS(WaitForRequestWithTimeOut(dialStatus, ETimeMedium), KErrNone, _L("RMobileCall::Dial timed-out"));

	ASSERT_EQUALS(dialStatus.Int(), KErrNone, _L("RMobileCall::Dial returned error."));

	// Verify packet service and context are suspended. 

	RPacketService::TStatus expectedPacketServiceStatus = RPacketService::EStatusSuspended;

	iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(packetService,

	                                                                notifyServiceStatusChange,

	                                                                packetServiceStatus,

	                                                                expectedPacketServiceStatus,

	                                                                KErrNone);

	RPacketContext::TContextStatus expectedPacketContextStatus = RPacketContext::EStatusSuspended;

	iPacketServiceTestHelper.WaitForPacketContextNotifyStatusChange(packetContext,

	                                                                notifyContextStatusChange,

	                                                                packetContextStatus,

	                                                                expectedPacketContextStatus,

	                                                                KErrNone);

	// Repost notification for service's status change

	packetService.NotifyStatusChange(notifyServiceStatusChange, packetServiceStatus);

	// Repost notification for context's status change

	packetContext.NotifyStatusChange(notifyContextStatusChange, packetContextStatus);

	// Hang up. 

	mobileCall.HangUp(hangUpStatus);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(hangUpStatus, ETimeMedium), KErrNone, _L("RMobileCall::HangUp timed-out"));

	ASSERT_EQUALS(hangUpStatus.Int(), KErrNone, _L("RMobileCall::CallHangUp returned an error"));

	// Verify packet service and context are active again. 

    expectedPacketServiceStatus = RPacketService::EStatusActive;

	iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(packetService,

	                                                                notifyServiceStatusChange,

	                                                                packetServiceStatus,

	                                                                expectedPacketServiceStatus,

	                                                                KErrNone);

	expectedPacketContextStatus = RPacketContext::EStatusActive;

	iPacketServiceTestHelper.WaitForPacketContextNotifyStatusChange(packetContext,

	                                                                notifyContextStatusChange,

	                                                                packetContextStatus,

	                                                                expectedPacketContextStatus,

	                                                                KErrNone);

	//

	// TEST END

	//

    StartCleanup();

	// Pop

	// notifyLineChangeStatus

	// dialStatus

	// hangUpStatus

	// notifyServiceStatusChange

	// notifyContextStatusChange

	CleanupStack::PopAndDestroy(5, &notifyLineChangeStatus);

	return TestStepResult();

	}

TPtrC CCTSYIntegrationTestMultiBearerInteroperability0001::GetTestStepName()

/**

 * @return The test step name.

 */

	{

	return _L("CCTSYIntegrationTestMultiBearerInteroperability0001");

	}

CCTSYIntegrationTestMultiBearerInteroperability0002::CCTSYIntegrationTestMultiBearerInteroperability0002(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestMultiBearerInteroperabilityBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestMultiBearerInteroperability0002::GetTestStepName());

	}

CCTSYIntegrationTestMultiBearerInteroperability0002::~CCTSYIntegrationTestMultiBearerInteroperability0002()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestMultiBearerInteroperability0002::doTestStepL()

/**

 * @SYMTestCaseID BA-CTSY-INT-MBI-0002

 * @SYMFssID BA/CTSY/MBI-0002

 * @SYMTestCaseDesc Verify simultaneous PS connection and MO SMS

 * @SYMTestPriority High

 * @SYMTestActions RPacketContext::NotifyStatusChange, RPacketService::NotifyStatusChange, RMobileSmsMessaging::SendMessage

 * @SYMTestExpectedResults Pass - MO SMS sent.

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

 * Reason for test: 

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

	// Ensure phone is camped on a valid cell. 

	// Ensure phone is attached to packet service. 

	// Get voice line 1. 

	// Get call 1. 

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// Send an SMS.   

	// Verify SMS can be sent. 

	// Activate a PDP context. 

	// Send an SMS. 

	// Verify SMS can be sent. 

	// Verify packet service and context become suspended and the active again when message sent. 

	//

	// TEST END

	//

    StartCleanup();

	// Put any required test clean up here, then remove this comment

	return TestStepResult();

	}

TPtrC CCTSYIntegrationTestMultiBearerInteroperability0002::GetTestStepName()

/**

 * @return The test step name.

 */

	{

	return _L("CCTSYIntegrationTestMultiBearerInteroperability0002");

	}

CCTSYIntegrationTestMultiBearerInteroperability0003::CCTSYIntegrationTestMultiBearerInteroperability0003(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestMultiBearerInteroperabilityBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestMultiBearerInteroperability0003::GetTestStepName());

	}

CCTSYIntegrationTestMultiBearerInteroperability0003::~CCTSYIntegrationTestMultiBearerInteroperability0003()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestMultiBearerInteroperability0003::doTestStepL()

/**

 * @SYMTestCaseID BA-CTSY-INT-MBI-0003

 * @SYMFssID BA/CTSY/MBI-0003

 * @SYMTestCaseDesc 3G-2G handover with PDP context active

 * @SYMTestPriority High

 * @SYMTestActions RPacketContext::NotifyDataTransferred, RPacketContext::GetDataVolumeTransferred, RMobilePhone::GetNetworkRegistrationStatus, RMobilePhone::NotifyNetworkRegistrationStatusChange

 * @SYMTestExpectedResults Pass - File continues downloading after each cell reselection, service is never lost.

 * @SYMTestType CIT

 * @SYMTestCaseDependencies simulated/manual

 *

 * Reason for test: 

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

	ERR_PRINTF2(_L("<font color=Orange>$CTSYProblem: defect id = %d</font>"), 10071);

	User::Leave(KErrNone);	

	// Ensure phone is camped on a valid cell. 

	RMobilePhone& phone = iEtelSessionMgr.GetPhoneL(KMainServer, KMainPhone);

    CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(phone), KErrNone, _L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

	// Ensure phone has KCapsNotifyRegistrationStatus and KCapsNotifyCurrentNetwork capabilities. 

	TUint32 caps;

	CHECK_EQUALS_L(phone.GetNetworkCaps(caps), KErrNone, _L("RMobilePhone::GetNetworkCaps returned an error"));

	TUint32 wantedCaps = RMobilePhone::KCapsNotifyRegistrationStatus | RMobilePhone::KCapsNotifyCurrentNetwork;

	CHECK_BITS_SET_L(caps, wantedCaps, KNoUnwantedBits, _L("RMobilePhone::GetNetworkCaps returned wrong caps"));

	// Ensure phone is attached to packet service. 

	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer, KMainPhone, KMainPacketService);

    SetAttachModeToWhenPossibleAndWaitForAttachL(packetService);

	// Get Voice line 1. 

	RMobileLine& voiceLine = iEtelSessionMgr.GetLineL(KMainServer, KMainPhone, KVoiceLine);

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// Start downloading a file via HTTP. 

    CHTTPDownload* download = new (ELeave) CHTTPDownload(this);

    CleanupStack::PushL(download);

 	// Get context info	

	TExtEtelRequestStatus getContextInfo(packetService, EPacketGetContextInfo);

	CleanupStack::PushL(getContextInfo);

	RPacketService::TContextInfo contextInfo;

	TInt index = 0;

	packetService.GetContextInfo(getContextInfo, index, contextInfo);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(getContextInfo, ETimeLong), KErrNone, _L("RPacketService::GetContextInfo timed out"));

	ASSERT_EQUALS(getContextInfo.Int(), KErrNone, _L("RPacketService::GetContextInfo returned an error"));

	ASSERT_TRUE(contextInfo.iName.Length() > 0, _L("RPacketService::GetContextInfo returned with zero length context name"));

	// Open a handle on an existing context with OpenExistingContext

	RPacketContext primaryPacketContext;										

    ASSERT_EQUALS(primaryPacketContext.OpenExistingContext(packetService, contextInfo.iName), KErrNone, _L("RPacketContext::OpenExistingContext returned with an error."));

	// Post notification for network change

	RMobilePhone::TMobilePhoneNetworkInfoV1 netInfo;

	RMobilePhone::TMobilePhoneLocationAreaV1 locationArea;

	TPckg<RMobilePhone::TMobilePhoneNetworkInfoV1> netInfoPckg(netInfo);

	TExtEtelRequestStatus notifyCurrentNetworkChangeStatus(phone, EMobilePhoneNotifyCurrentNetworkChange);

	CleanupStack::PushL(notifyCurrentNetworkChangeStatus);

	phone.NotifyCurrentNetworkChange(notifyCurrentNetworkChangeStatus, netInfoPckg, locationArea);	

	// Request status for RLine::NotifyIncomingCall

	TCoreEtelRequestStatus<RLine> notifyIncomingCallStatus (voiceLine, &RLine::NotifyIncomingCallCancel);

	CleanupStack::PushL(notifyIncomingCallStatus);

	TName incomingCallName;

	// Get tranferred data for later comparison

    RPacketContext::TDataVolume dataVolume;	

	primaryPacketContext.GetDataVolumeTransferred(dataVolume);	

	TUint32 lastBytesSent = dataVolume.iBytesSent;