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

//

/**

 @file The TEFUnit test suite for LaunchBrowser in the SAT.

*/

#include <satcs.h>

#include <ctsy/ltsy/sat_defs.h>

#include <ctsy/ltsy/mltsydispatchsatinterface.h>

#include <test/mockltsyindicatorids.h>

#include <test/tmockltsydata.h>

#include "ccsatlaunchbrowserfu.h"

static const TUint8 KCommandNumber = 1;

static const TUint8 KCommandType   = KLaunchBrowser;

static const TUint8 KSourceDevice = KSim;

static const TUint8 KDestinationDevice = KMe;

static const TUint8 KCodingScheme = K8BitDCS;

static const TInt KDelay = 10;

_LIT8(KURL, "www.symbian.ru");

_LIT8(KBearerList, "\x01\x03\x01\x03");

_LIT8(KText, "Gateway/Proxy");

_LIT8(KAlphaId, "phase");

_LIT8(KNULL, "\x00");

_LIT8(KFileRef, "1234567890");

CTestSuite* CCSatLaunchBrowserFU::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCSatLaunchBrowserFU, TestNotifyLaunchBrowserPCmd0001L);

	ADD_TEST_STEP_ISO_CPP(CCSatLaunchBrowserFU, TestNotifyLaunchBrowserPCmd0002L);

	ADD_TEST_STEP_ISO_CPP(CCSatLaunchBrowserFU, TestNotifyLaunchBrowserPCmd0004L);

	END_SUITE;

	}

void CCSatLaunchBrowserFU::PrepareTlvData ( TTlv& aTlvData )

	{	

	aTlvData.Begin(KBerTlvProactiveSimCommandTag);

	aTlvData.AddTag(KTlvCommandDetailsTag);         // Command details

	aTlvData.AddByte(KCommandNumber);               // Command number

	aTlvData.AddByte(KCommandType);                 // Command type

	aTlvData.AddByte(iData.iCommandQualifier);      // Command qualifier

	aTlvData.AddTag(KTlvDeviceIdentityTag);         // Device identities

	aTlvData.AddByte(KSourceDevice);                // Source device

	aTlvData.AddByte(KDestinationDevice);           // Destination device

	if ( iData.iUrl.Length() > 0 )

		{

		aTlvData.AddTag(KTlvUrlTag);

		aTlvData.AddData(iData.iUrl);

		}

	if ( iData.iBearerList.Length() > 0 )

		{

		aTlvData.AddTag(KTlvBearerTag);

		aTlvData.AddData(iData.iBearerList);

		}

	if ( iData.iText.Length() > 0 )

		{

		aTlvData.AddTag(KTlvTextStringTag);

		aTlvData.AddByte(KCodingScheme);

		aTlvData.AddData(iData.iText);

		}

	if ( iData.iAlphaId.Length() > 0 || iData.iIfAlphaId )

		{

		aTlvData.AddTag(KTlvAlphaIdentifierTag);

		aTlvData.AddData(iData.iAlphaId);

		}

	if ( iData.iIfUsedBrowserId )

		{

		aTlvData.AddTag(KTlvBrowserIdentityTag);

		aTlvData.AddByte(iData.iBrowserId);

		}

	if ( iData.iFileRef.Length() > 0 )

		{

		aTlvData.AddTag(KTlvProvisioningReferenceFileTag);

		aTlvData.AddData(iData.iFileRef);

		aTlvData.AddTag(KTwoByteLengthCoding);

		}

	}

void CCSatLaunchBrowserFU::PrepareExpectDataL ()

	{

	RBuf8 data;

	CleanupClosePushL(data);	

	TUint8 commandType = KLaunchBrowser;

	TMockLtsyData1<TUint8> expLtsyData(commandType);

	expLtsyData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, data);

	CleanupStack::PopAndDestroy(1); // data

	}

void CCSatLaunchBrowserFU::PrepareCompleteDataL ( TInt aResultCode )

	{

	RBuf8 data;

	CleanupClosePushL(data);	

	TTlv tlv;

	PrepareTlvData( tlv );

	TPtrC8 tlvDsc = tlv.End();

	TDesC8* tlvDscPtr = &tlvDsc;

	TMockLtsyData1<TDesC8*> tlvDscPack(tlvDscPtr);

	tlvDscPack.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId, aResultCode, data, KDelay);

	CleanupStack::PopAndDestroy(1); // data

	}

void CCSatLaunchBrowserFU::ProactiveCommandCallL( 

		RSat::TLaunchBrowserV2& aLaunchBrowserData,

		TInt aCompleteErrorCode,

		TInt aResultCode,

		TBool aIfCreateTerminal,

		RSat::TPCmdResult aGeneralResult,

		TUint8 aCommandQualifier,

		const TDesC& aAdditionalInfo

		)

	{

	TRequestStatus requestStatus;

	PrepareExpectDataL ();

	RSat::TLaunchBrowserV2Pckg setpPck(aLaunchBrowserData);

	iSat.NotifyLaunchBrowserPCmd(requestStatus, setpPck);

	PrepareCompleteDataL ( aCompleteErrorCode );

	if ( aIfCreateTerminal )

		{

		PrepareTerminalResponseMockDataL(

				KCommandNumber,

				KCommandType,

				aCommandQualifier,

				aAdditionalInfo,

				aGeneralResult,

				KNullDesC8);

		}

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(aResultCode, requestStatus.Int());

	AssertMockLtsyStatusL();

	}

void CCSatLaunchBrowserFU::DataInitialization(

		TUint8 aCommandQualifier,

		const TDesC8& aUrl,

		const TDesC8& aBearerList,

		const TDesC8& aText,

		const TDesC8& aAlphaId,

		const TDesC8& aFileRef,

		TBool aIfUsedBrowserId,

		TUint aBrowserId,

		TBool aIfAlphaId

		)

	{

	iData.iUrl.Copy(aUrl);

	iData.iBearerList.Copy(aBearerList);

	iData.iText.Copy(aText);

	iData.iAlphaId.Copy(aAlphaId);

	iData.iFileRef.Copy(aFileRef);

	iData.iCommandQualifier = aCommandQualifier;

	iData.iBrowserId = aBrowserId;

	iData.iIfUsedBrowserId = aIfUsedBrowserId;

	iData.iIfAlphaId = aIfAlphaId;

	}

void CCSatLaunchBrowserFU::TerminalResponseCallL(

		const RSat& aSat,

		RSat::TPCmdResult aGeneralResult,

		const TDesC& aAdditionalInfo,

		TInt aResultCode,

		TUint aInfoType

		)

	{

	RSat::TLaunchBrowserRspV2 launchBrowser;

	RSat::TLaunchBrowserRspV2Pckg launchBrowserPckg(launchBrowser);

	TRequestStatus requestStatus;

	launchBrowser.iGeneralResult = aGeneralResult;

	launchBrowser.SetPCmdNumber(KCommandNumber);

	launchBrowser.iInfoType = aInfoType;

	PrepareTerminalResponseMockDataL(

			KCommandNumber,

			KCommandType,

			iData.iCommandQualifier,

			aAdditionalInfo,

			launchBrowser.iGeneralResult,

			KNullDesC8);

	aSat.TerminalRsp(requestStatus, RSat::ELaunchBrowser, launchBrowserPckg);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(aResultCode, requestStatus.Int());

	}

void CCSatLaunchBrowserFU::DataCompareL( const RSat::TLaunchBrowserV2& aLaunchBrowser )

	{

	RSat::TBrowserSelection browserSel;

	switch( iData.iCommandQualifier )

		{

		case KLaunchBrowserIfNotYetLaunched:

			browserSel = RSat::ELaunchBrowserIfNotAlreadyLaunched;

			break;

		case KUseExistingBrowser:

			browserSel = RSat::EUseExistingBrowser;

			break;

		case KCloseAndLaunchNewBrowser:

			browserSel = RSat::ECloseExistingLaunchNewBrowserSession;

			break;

		case KLaunchBrowserCmdQualifierNotUsed:

		case KLaunchBrowserCmdQualifierReserved:

		default:

			browserSel = RSat::EBrowserSelectionNotSet;

		}

	ASSERT_EQUALS( browserSel, aLaunchBrowser.iBrowserSel );

	RSat::TAlphaIdBuf alphaId;

	alphaId.Copy(iData.iAlphaId);

	ASSERT_EQUALS( 0, alphaId.Compare( aLaunchBrowser.iAlphaId.iAlphaId ) );

	RSat::TTextString text;

	text.Copy( iData.iText );

	ASSERT_EQUALS( 0, text.Compare( aLaunchBrowser.iText ) );

	ASSERT_EQUALS( 0, iData.iBearerList.Compare( aLaunchBrowser.iBearerList ) );

	ASSERT_EQUALS( 0, iData.iUrl.Compare( aLaunchBrowser.iUrl ) );

	}

void CCSatLaunchBrowserFU::ClearData( RSat::TLaunchBrowserV2& aLaunchBrowser )

	{

	aLaunchBrowser.ResetFileRef();

	aLaunchBrowser.iBrowserSel = RSat::EBrowserSelectionNotSet;

	aLaunchBrowser.iBrowserId  = RSat::EBrowserIdNotSet;

	aLaunchBrowser.iUrl.Zero();

	aLaunchBrowser.iBearerList.Zero();

	aLaunchBrowser.iText.Zero();

	aLaunchBrowser.iAlphaId.iAlphaId.Zero();

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CSAT-LB-SNLBPC-0001

@SYMPREQ 1780

@SYMComponent  telephony_csat

@SYMTestCaseDesc Test support in CSAT for RSat::NotifyLaunchBrowserPCmd

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifyLaunchBrowserPCmd

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCSatLaunchBrowserFU::TestNotifyLaunchBrowserPCmd0001L()

	{

	static const TUint8 KCmdQualifierArray[] = { 

			KLaunchBrowserCmdQualifierNotUsed, 

			KUseExistingBrowser, 

			KCloseAndLaunchNewBrowser,

			KLaunchBrowserCmdQualifierReserved, 

			KLaunchBrowserCmdQualifierReserved + 1 };

	static const RSat::TPCmdResult KGenResultArray[] = {

			RSat::KPSessionTerminatedByUser,

			RSat::KBackwardModeRequestedByUser,

			RSat::KNoResponseFromUser,

			RSat::KMeUnableToProcessCmd,

			RSat::KCmdBeyondMeCapabilities,

			RSat::KCmdDataNotUnderstood,

			RSat::KLaunchBrowserError,

			RSat::KPCmdNotAcceptedByUser,

			RSat::KCmdTypeNotUnderstood,

			RSat::KMissingInformation,

			RSat::KPartialComprehension,

			RSat::KNetworkUnableToProcessCmd,

			RSat::KCmdNumberNotKnown };

	static const TUint KArrayInfoType[] = {

			RSat::KMeProblem,

			RSat::KBearerUnvailable,

			RSat::KBrowserUnavailable,

			RSat::KMeUnableToReadProvisioningData,

			RSat::KNoSpecificBrowserError,

			RSat::KServiceError };

	const TInt KSize = sizeof(KCmdQualifierArray)/sizeof(KCmdQualifierArray[0]);

	const TInt KArraySize = sizeof(KGenResultArray)/sizeof(KGenResultArray[0]);

	const TInt KArrayITSize = sizeof(KArrayInfoType)/sizeof(KArrayInfoType[0]);

	const TUint8 KCommandQualifier = KLaunchBrowserIfNotYetLaunched;

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	OpenSatL();

	RSat::TLaunchBrowserV2 launchBrowser;

	TRequestStatus requestStatus;

	DataInitialization(KCommandQualifier, KURL, KBearerList, KText, KAlphaId, KFileRef);

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

	// TEST C: Successful completion request of

	// RSat::NotifyLaunchBrowserPCmd 

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

	ProactiveCommandCallL(launchBrowser);

	TerminalResponseCallL(iSat);

	DataCompareL( launchBrowser );

	AssertMockLtsyStatusL();

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

	// TEST E: Coverage test(s) for RSat::NotifyLaunchBrowserPCmd

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

	iMockLTSY.NotifyTerminated(requestStatus);

	PrepareCompleteDataL ();

	RSat::TAdditionalInfo additionalInfo;

	additionalInfo.Append(RSat::KNoSpecificMeProblem);

	PrepareTerminalResponseMockDataL(

			KCommandNumber,

			KCommandType,

			KCommandQualifier,

			additionalInfo,

			RSat::KMeUnableToProcessCmd,

			KNullDesC8);

	User::WaitForRequest(requestStatus);

	ASSERT_EQUALS(KErrNone, requestStatus.Int());

	AssertMockLtsyStatusL();

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

	// to increase CSatNotifyLaunchBrowser::CompleteNotifyL coverage 

	// in case of "switch ( cmdQualifier )"

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

	TBool prepareMockData = EFalse;

	TUint8 element = 0;

	for ( TInt i = 0; i < KSize; i++ )

		{

		element = KCmdQualifierArray[i];

		prepareMockData = 

			element == KLaunchBrowserCmdQualifierNotUsed || 

			element == KLaunchBrowserCmdQualifierReserved;

		DataInitialization(element, KURL, KBearerList, KText, KAlphaId, KFileRef);

		ClearData(launchBrowser);

		if ( prepareMockData )

			{

			ProactiveCommandCallL(

					launchBrowser, 

					KErrNone, 

					KErrCorrupt, 

					ETrue, 

					RSat::KCmdTypeNotUnderstood,

					element);

			}

		else

			{

			ProactiveCommandCallL(launchBrowser); 

			}

		if ( !prepareMockData )

			{

			TerminalResponseCallL(iSat);

			DataCompareL( launchBrowser );

			}

		AssertMockLtsyStatusL();

		}

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

	// to increase CSatNotifyLaunchBrowser::TerminalResponseL coverage 

	// in case of general result value isn't valid

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

	RSat::TPCmdResult elementResult;

	TInt resultCode = KErrNone;

	for (TInt i = 0; i < KArraySize; i++)

		{

		elementResult = KGenResultArray[i];

		additionalInfo.Zero();

		switch( elementResult )

			{

			case RSat::KCmdDataNotUnderstood:

			case RSat::KCmdTypeNotUnderstood:

			case RSat::KMissingInformation:

			case RSat::KPartialComprehension:

				{

				break;

				}			

			default:

				{

				additionalInfo.Append(RSat::KNoSpecificMeProblem);

				}

			}

		TerminalResponseCallL(iSat, elementResult, additionalInfo, resultCode);

		AssertMockLtsyStatusL();

		}

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

	// to increase CSatNotifyLaunchBrowser::TerminalResponseL coverage 

	// in case of infotype isn't valid

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

	TUint elementIT;

	for (TInt i = 0; i < KArrayITSize; i++)

		{

		elementIT = KArrayInfoType[i];

		if ( RSat::KMeProblem    == elementIT ||

			 RSat::KServiceError == elementIT )

			{

			resultCode = KErrCorrupt;

			}

		else

			{

			resultCode = KErrNone;

			}

		TerminalResponseCallL(iSat, RSat::KSuccess, KNullDesC, resultCode, elementIT);

		AssertMockLtsyStatusL();

		}

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

	// to increase CSatNotifyLaunchBrowser::ParseBrowserIdL coverage 

	// in case of "if ( 0x00 == aLaunchBrowserV2.iBearerList.Length() )"

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

	DataInitialization(KCommandQualifier, KURL, KBearerList, KText, KAlphaId, KFileRef, ETrue);

	ClearData(launchBrowser);

	ProactiveCommandCallL(launchBrowser);

	AssertMockLtsyStatusL();

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

	// to increase CSatNotifyLaunchBrowser::ParseBrowserIdL coverage 

	//  in case of "if ( 0x00 != browserId.GetShortInfo( ETLV_BrowserIdentity ) )"

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

	TUint browserId = RSat::EBrowserIdNotPresent;

	DataInitialization(KCommandQualifier, KURL, KBearerList, KText, KAlphaId, KFileRef, ETrue, browserId);

	ClearData(launchBrowser);

	ProactiveCommandCallL(

			launchBrowser, 

			KErrNone, 

			KErrCorrupt, 

			ETrue, 

			RSat::KCmdDataNotUnderstood);

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

	// to increase CSatNotifyLaunchBrowser::ParseUrlL coverage 

	// in case of KTlvUrlTag isn't found.

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