// 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 PacketService functional unit.

// 

//

/**

 @internalTechnology

*/

#include <etelpckt.h>

#include <pcktcs.h>

#include "cctsyintegrationtestpacketservice.h"

#include "cetelsessionmgr.h"

#include "tetelrequeststatus.h"

#include "tsmsstoretsytesthelper.h"

_LIT(KPrompt, "This test requires network simulation,Press a key if simualted network is ready");

CCTSYIntegrationTestPacketServiceBase::CCTSYIntegrationTestPacketServiceBase(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestSuiteStepBase(aEtelSessionMgr), iPacketServiceTestHelper(*this), iNetworkTestHelper(*this)

/**

 * Constructor

 */

	{

	}

CCTSYIntegrationTestPacketServiceBase::~CCTSYIntegrationTestPacketServiceBase()

/*

 * Destructor

 */

	{

	}

/**

 * Ensures that the correct attach mode is set and leaves if not

 @param aPacketService RPacketService service

 @param aModeAttach give information about the desired mode. The function leaves if the required mode is not there.

 */

 void CCTSYIntegrationTestPacketServiceBase::EnsureAttachModeL( RPacketService &aPacketService, RPacketService::TAttachMode &aModeAttach)

 	{

 	// Get attach mode to check whether it is already RPacketService::EAttachWhenNeeded		

	TExtEtelRequestStatus getAttachModeStatus (aPacketService,EPacketGetAttachMode);

	CleanupStack::PushL(getAttachModeStatus);	

	RPacketService::TAttachMode attachMode;

	aPacketService.GetAttachMode(getAttachModeStatus, attachMode);

	CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAttachModeStatus, ETimeMedium), KErrNone, 

					_L("PacketService::GetAttachMode timed out"));

	CHECK_EQUALS_L(getAttachModeStatus.Int(), KErrNone, 

					_L("PacketService::GetAttachMode returned an error"));

	// If the attach mode is not RPacketService::EAttachWhenNeeded, then set it

	TExtEtelRequestStatus setAttachModeStatus(aPacketService, EPacketSetAttachMode);

	CleanupStack::PushL(setAttachModeStatus);	

	if (attachMode != aModeAttach)	

		{

		// Set attach mode to RPacketService::EAttachWhenNeeded with RPacketService::SetAttachMode

		aPacketService.SetAttachMode(setAttachModeStatus, aModeAttach);

		CHECK_EQUALS_L(WaitForRequestWithTimeOut(setAttachModeStatus, ETimeLong), KErrNone,	

						_L("PacketService::SetAttachMode timed out."));								

		CHECK_EQUALS_L(setAttachModeStatus.Int(), KErrNone, 

						_L("PacketService::SetAttachMode returned an error"));		

		// Check that it was set

		aPacketService.GetAttachMode(getAttachModeStatus,attachMode);

		CHECK_EQUALS_L(WaitForRequestWithTimeOut(getAttachModeStatus, ETimeMedium), KErrNone,

						_L("PacketService::GetAttachMode timed out"));

		CHECK_EQUALS_L(getAttachModeStatus.Int(), KErrNone, 

						_L("PacketService::GetAttachMode returned an error"));			

		}		

	CHECK_EQUALS_L(attachMode, aModeAttach, _L("PacketService::GetAttachMode did not return the desired attach mode"));

	// getAttachModeStatus

	// setAttachModeStatus

	CleanupStack::PopAndDestroy(2, &getAttachModeStatus);

 	}

 //*************************************************************************	

CCTSYIntegrationTestPacketService0001::CCTSYIntegrationTestPacketService0001(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestPacketServiceBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestPacketService0001::GetTestStepName());

	}

CCTSYIntegrationTestPacketService0001::~CCTSYIntegrationTestPacketService0001()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestPacketService0001::doTestStepL()

/**

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

 * @SYMFssID BA/CTSY/PKTS-0001

 * @SYMTestCaseDesc Get static caps.

 * @SYMTestPriority High

 * @SYMTestActions 

 * @SYMTestExpectedResults Pass - Static caps returned.

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

 * Reason for test: Get static caps for each protocol type.

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// Get packet service 

	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer, 

																	  KMainPhone,

																	  KMainPacketService);

	// Check static caps are 

	// RPacketService::KCapsSuspendSupported |

	// RPacketService::KCapsNetworkAvailabilitySupported | 

	// RPacketService::KCapsSetDefaultContextSupported | RPacketService::KCapsChangeAttachModeSupported | 

	// RPacketService::KCapsGetDataTransferredSupported | RPacketService::KCapsPreferredBearerSupported | 

	// RPacketService::KCapsPdpDataCompSupported | RPacketService::KCapsPdpHeaderCompSupported | 

	// RPacketService::KCapsNotifyMSClassSupported

	TUint staticCaps = 0;

	TUint expectedCaps = 	RPacketService::KCapsSuspendSupported |

							RPacketService::KCapsNetworkAvailabilitySupported | 

							RPacketService::KCapsSetDefaultContextSupported | 

							RPacketService::KCapsChangeAttachModeSupported | 

							RPacketService::KCapsGetDataTransferredSupported | 

							RPacketService::KCapsPreferredBearerSupported | 

							RPacketService::KCapsPdpDataCompSupported | 

							RPacketService::KCapsPdpHeaderCompSupported | 

							RPacketService::KCapsNotifyMSClassSupported;

	ASSERT_EQUALS(packetService.GetStaticCaps(staticCaps, RPacketContext::EPdpTypeIPv4), KErrNone, _L("RPacketService::GetStaticCaps returned an error"));

	ASSERT_BITS_SET(staticCaps, expectedCaps, KNoUnwantedBits,

			_L("RPacketService::GetStaticCaps did not return correct static caps"));

	//

	// TEST END

	//

    StartCleanup();

	return TestStepResult();

	}

TPtrC CCTSYIntegrationTestPacketService0001::GetTestStepName()

/**

 * @return The test step name.

 */

	{

	return _L("CCTSYIntegrationTestPacketService0001");

	}

CCTSYIntegrationTestPacketService0002::CCTSYIntegrationTestPacketService0002(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestPacketServiceBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestPacketService0002::GetTestStepName());

	}

CCTSYIntegrationTestPacketService0002::~CCTSYIntegrationTestPacketService0002()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestPacketService0002::doTestStepL()

/**

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

 * @SYMFssID BA/CTSY/PKTS-0002

 * @SYMTestCaseDesc Automatic attach to the packet service when attach mode changed to EAttachWhenPossible.

 * @SYMTestPriority High

 * @SYMTestActions RPacketService::NotifyAttachModeChange, RPacketService::GetNtwkRegStatus, RPacketService::GetStatus, RPacketService::GetAttachMode, RPacketService::NotifyDynamicCapsChange, RPacketService::GetDynamicCaps, RPacketService::NotifyStatusChange, RPacketService::GetStaticCaps

 * @SYMTestExpectedResults Pass - Phone automatically attached to packet service.

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

 * Reason for test: Verify that packet service attaches automatically when attach mode is changed to EAttachWhenPossible.

 * Verify static caps, packet network registration status,  dynamic caps are correct. 

 *

 * @return - TVerdict code

 */

	{

	//

	// SET UP

	//

	// Get packet service

	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer,

																	  KMainPhone,

																	  KMainPacketService);

	// Get mobile phone

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

	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone,

					_L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

	// Ensure attach mode is RPacketService::EAttachWhenNeeded

	RPacketService::TAttachMode attachMode= RPacketService::EAttachWhenNeeded; 

	EnsureAttachModeL(packetService,attachMode);

	User::After(10*KOneSecond); // This time delay is required to complete the implicit detach operation caused by EAttachWhenNeeded attach mode

	// Ensure packet service status is EStatusUnattached

	RPacketService::TStatus setUpStatus;

	CHECK_EQUALS_L(packetService.GetStatus(setUpStatus), KErrNone, 

					_L("PacketService::GetStatus returned an error"));

	TExtEtelRequestStatus detachStatus(packetService, EPacketDetach);

	CleanupStack::PushL(detachStatus);

	if (setUpStatus != RPacketService::EStatusUnattached)

		{

		packetService.Detach(detachStatus);

		CHECK_EQUALS_L(WaitForRequestWithTimeOut(detachStatus, ETimeMedium), KErrNone, 	

						_L("PacketService::Detach timed out"));

		CHECK_TRUE_L(detachStatus.Int()== KErrNone|| detachStatus.Int()== KErrAlreadyExists, 

						_L("PacketService::Detach returned an error"));										

		}

	User::After(5*KOneSecond); // Time delay is needed to detach properly

	//

	// SET UP END

	//

	StartTest();

	//

	// TEST START

	//

	// Check RPacketService::GetStatus returns RPacketService::EStatusUnattached

	RPacketService::TStatus serviceStatus; 

	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone,

					_L("PacketService::GetStatus returned with an error."));

	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusUnattached, 

					_L("RPacketService::GetStatus did not return RPacketService::EStatusUnattached."));

	// Check RPacketService::GetDynamicCaps returns caps in set of 

	// RPacketService::KCapsManualAttach | RPacketService::KCapsRxCSCall

	// Check RPacketService::GetDynamicCaps returns caps NOT in set of 

	// RPacketService::KCapsSMSTransfer | RPacketService::KCapsManualDetach | 

	// RPacketService::KCapsRxContextActivationReq

	RPacketService::TDynamicCapsFlags dynCaps;

	ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone, 

					_L("RPacketService::GetDynamicCaps returned with an error"));

	RPacketService::TDynamicCapsFlags expectedCaps = 

					RPacketService::KCapsManualAttach | 

					RPacketService::KCapsRxCSCall;

	RPacketService::TDynamicCapsFlags unwantedCaps = 

					RPacketService::KCapsSMSTransfer | 

					RPacketService::KCapsManualDetach | 

					RPacketService::KCapsRxContextActivationReq;

	ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps,

		_L("RPacketService::GetDynamicCaps did not return correct dynamic caps")); // NOTE: Use ASSERT_BITS_SET for wanted and unwanted bits, name the variables expectedCaps and unwantedCaps or similar

	// Post notification for RPacketService::NotifyAttachModeChange   

	TExtEtelRequestStatus notifyAttachModeChangeStatus(packetService, EPacketNotifyAttachModeChange); // NOTE: Name the request status object so that it is possible to identify which API it is for since they cannot be used for a different API

	CleanupStack::PushL(notifyAttachModeChangeStatus); // NOTE: Always push EVERY TExtEtelRequestStatus and TCoreEtelRequestStatus onto the CleanupStack

	packetService.NotifyAttachModeChange(notifyAttachModeChangeStatus, attachMode);

	// Post notification for RPacketService::NotifyStatusChange

	TExtEtelRequestStatus notifyStatusStatus(packetService, EPacketNotifyStatusChange);

	CleanupStack::PushL(notifyStatusStatus); 

	RPacketService::TStatus packetServiceStatus;

	packetService.NotifyStatusChange(notifyStatusStatus, packetServiceStatus);

	// Post notification for RPacketService::NotifyDynamicCapsChange

	TExtEtelRequestStatus notifyDynamicCapsChangeStatus(packetService, EPacketNotifyDynamicCapsChange);

	CleanupStack::PushL(notifyDynamicCapsChangeStatus);

	packetService.NotifyDynamicCapsChange(notifyDynamicCapsChangeStatus, dynCaps);

	// Set attach mode to RPacketService::EAttachWhenPossible with RPacketService::SetAttachMode

	TExtEtelRequestStatus setAttachModeStatus(packetService, EPacketSetAttachMode);

	CleanupStack::PushL(setAttachModeStatus); 

	packetService.SetAttachMode(setAttachModeStatus, RPacketService::EAttachWhenPossible);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(setAttachModeStatus, ETimeLong), KErrNone, 

					_L("RPacketService::SetAttachMode timed-out")); 

	ASSERT_EQUALS(setAttachModeStatus.Int(), KErrNone, 

					_L("RPacketService::SetAttachMode returned with an error"));

	User::After(10*KOneSecond); // This time delay is required to complete the implicit attach operation caused by EAttachWhenPossible attach mode

	// Check RPacketService::NotifyAttachModeChange completes with RPacketService::EAttachWhenPossible  

	RPacketService::TAttachMode expectedAttachMode = RPacketService::EAttachWhenPossible;

	iPacketServiceTestHelper.WaitForPacketServiceNotifyAttachModeChange(packetService, 

																		notifyAttachModeChangeStatus, 

																		attachMode, 

																		expectedAttachMode, 

																		KErrNone);

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

	// Check RPacketService::GetAttachMode returns RPacketService::EAttachWhenPossible

	TExtEtelRequestStatus getAttachModeStatus(packetService, EPacketGetAttachMode);

	CleanupStack::PushL(getAttachModeStatus);

	packetService.GetAttachMode(getAttachModeStatus, attachMode);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(getAttachModeStatus, ETimeShort), KErrNone,

					_L("RPacketService::GetAttachMode timed-out"));

	ASSERT_EQUALS(getAttachModeStatus.Int(), KErrNone, 

					_L("RPacketService::GetAttachMode returned with an error"));

	ASSERT_EQUALS(attachMode, RPacketService::EAttachWhenPossible, 

					_L("RPacketService::GetAttachMode did not return RPacketService::EAttachWhenPossible"));

	// Check RPacketService::NotifyStatusChange completes with RPacketService::EStatusAttached

	RPacketService::TStatus expectedPacketServiceStatus = RPacketService::EStatusAttached;

	iPacketServiceTestHelper.WaitForPacketServiceNotifyStatusChange(packetService, 

																	notifyStatusStatus,

																	packetServiceStatus,

																	expectedPacketServiceStatus,

																	KErrNone);

	// Check RPacketService::NotifyDynamicCapsChange completes with caps in set of KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer

	// Check RPacketService::NotifyDynamicCapsChange completes with caps NOT in set of RPacketService::KCapsManualAttach

	expectedCaps = 	RPacketService::KCapsRxCSCall | 

					RPacketService::KCapsRxContextActivationReq | 

					RPacketService::KCapsManualDetach | 

					RPacketService::KCapsSMSTransfer;

	unwantedCaps =  RPacketService::KCapsManualAttach;

	iPacketServiceTestHelper.WaitForPacketServiceNotifyDynamicCapsChange(packetService,

																		 notifyDynamicCapsChangeStatus,

																		 dynCaps, 

																		 expectedCaps,

																		 unwantedCaps,

																		 KErrNone);

	// Check RPacketService::GetStatus returns RPacketService::EStatusAttached

	ASSERT_EQUALS(packetService.GetStatus(serviceStatus), KErrNone, 

					_L("RPacketService::GetStatus returned with an error"));

	ASSERT_EQUALS(serviceStatus, RPacketService::EStatusAttached, 

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

	// Check RPacketService::GetDynamicCaps returns caps in set of KCapsRxCSCall | KCapsRxContextActivationReq | KCapsManualDetach | KCapsSMSTransfer.

	// Check RPacketService::GetDynamicCaps completes with caps NOT in set of RPacketService::KCapsManualAttach

    ASSERT_EQUALS(packetService.GetDynamicCaps(dynCaps), KErrNone,

    				_L("RPacketService::GetDynamicCaps returned with an error"));

    expectedCaps = 	RPacketService::KCapsRxCSCall | 

    				RPacketService::KCapsRxContextActivationReq | 

    				RPacketService::KCapsManualDetach | 

    				RPacketService::KCapsSMSTransfer;

    unwantedCaps = 	RPacketService::KCapsManualAttach;

    ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps, 

    		_L("RPacketService::GetDynamicCaps did not return correct dynamic caps"));

	// Check RPacketService::GetNtwkRegStatus returns ERegisteredOnHomeNetwork

    TExtEtelRequestStatus regStatus(packetService, EPacketGetNtwkRegStatus);

    CleanupStack::PushL(regStatus);

    RPacketService::TRegistrationStatus registrationStatus;

    packetService.GetNtwkRegStatus(regStatus, registrationStatus);

	ASSERT_EQUALS(WaitForRequestWithTimeOut(regStatus, ETimeMedium), KErrNone,

					_L("RPacketService::GetNtwkRegStatus timed-out."));

	ASSERT_EQUALS(regStatus.Int(), KErrNone, 

					_L("RPacketService::GetNtwkRegStatus returned with an error"));

    ASSERT_EQUALS(registrationStatus, RPacketService::ERegisteredOnHomeNetwork, 

    				_L("RPacketService::GetNtwkRegStatus did not return RPacketService::ERegisteredOnHomeNetwork"));

    //

    // Test end

    //

    StartCleanup();

    // Pop:

	// detachStatus

	// notifyAttachModeChangeStatus

    // notifyStatusStatus

	// notifyDynamicCapsChangeStatus

	// setAttachModeStatus

	// getAttachModeStatus

	// regStatus

	CleanupStack::PopAndDestroy(7, &detachStatus); 

	return TestStepResult();

	}

TPtrC CCTSYIntegrationTestPacketService0002::GetTestStepName()

/**

 * @return The test step name.

 */

	{

	return _L("CCTSYIntegrationTestPacketService0002");

	}

CCTSYIntegrationTestPacketService0003::CCTSYIntegrationTestPacketService0003(CEtelSessionMgr& aEtelSessionMgr)

	: CCTSYIntegrationTestPacketServiceBase(aEtelSessionMgr)

/**

 * Constructor.

 */

	{

	SetTestStepName(CCTSYIntegrationTestPacketService0003::GetTestStepName());

	}

CCTSYIntegrationTestPacketService0003::~CCTSYIntegrationTestPacketService0003()

/**

 * Destructor.

 */

	{

	}

TVerdict CCTSYIntegrationTestPacketService0003::doTestStepL()

/**

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

 * @SYMFssID BA/CTSY/PKTS-0003

 * @SYMTestCaseDesc Automatic attach to the packet service, when Context Activated and attach mode is EAttachWhenNeeded.

 * @SYMTestPriority High

 * @SYMTestActions RPacketService::GetNtwkRegStatus, RPacketService::GetStatus, RPacketService::GetAttachMode, RPacketService::NotifyDynamicCapsChange, RPacketService::GetDynamicCaps, RPacketService::NotifyStatusChange, RPacketService::NotifyContextAdded, RPacketService::EnumerateContexts, RPacketContext::NotifyStatusChange, RPacketContext::GetStatus

 * @SYMTestExpectedResults Pass - Packet service is active.

 * @SYMTestType CIT

 * @SYMTestCaseDependencies live/automatic

 *

 * Reason for test: Verify that automatic attach occurs when a packet context is activated.

Verify packet network registration status,  dynamic caps, number of active contexts, context status are correct.

 *

 * @return - TVerdict code

 */

	{

	// Attach to the packet service with attach mode set to EAttachWhenNeeded by Activating a context

	//

	// SET UP

	//

	// Start with attach mode in RPacketService::EAttachWhenNeeded.

	// Get packet service

	RPacketService& packetService = iEtelSessionMgr.GetPacketServiceL(KMainServer,

																	  KMainPhone,

																	  KMainPacketService);

	// Get mobile phone

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

	// Get packet context

	RPacketContext& packetContext = iEtelSessionMgr.GetPrimaryPacketContextL(KMainServer,

																			 KMainPhone,

																			 KMainPacketService,

																			 KPrimaryPacketContext1); 

	// Call TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL		

	CHECK_EQUALS_L(iNetworkTestHelper.WaitForRegisteredOnHomeNetworkL(mobilePhone), KErrNone,

					_L("TNetworkTsyTestHelper::WaitForRegisteredOnHomeNetworkL returned with an error"));

	// Ensure attach mode is RPacketService::EAttachWhenNeeded

	RPacketService::TAttachMode attachMode= RPacketService::EAttachWhenNeeded; 

	EnsureAttachModeL(packetService,attachMode);

	User::After(10*KOneSecond); // This time delay is required to complete the implicit detach operation caused by EAttachWhenNeeded attach mode

	// Ensure packet service status is EStatusUnattached

	RPacketService::TStatus setUpStatus;

	CHECK_EQUALS_L(packetService.GetStatus(setUpStatus), KErrNone, 

					_L("PacketService::GetStatus returned an error"));

	TExtEtelRequestStatus detachStatus(packetService, EPacketDetach);

	CleanupStack::PushL(detachStatus);

	if (setUpStatus != RPacketService::EStatusUnattached)

		{

		packetService.Detach(detachStatus);

		CHECK_EQUALS_L(WaitForRequestWithTimeOut(detachStatus, ETimeMedium), KErrNone,