// Copyright (c) 2006-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 ConnectionServer.TestSteps.cpp

// 

//

#include <commdbconnpref.h>

#include <simtsy.h>

#include <cs_subconevents.h>

#include "ConnectionServer.TestSteps.h"

#include "networking\qos3gpp_subconparams.h"

#include <in_sock.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockTestCnctnSr, "ESockTestCnctnSr");

#endif

const TUint KMaxAccessPoints = 16;

_LIT(KAccessPointFilter, "QueryAPStatusFilter");

_LIT(KQueryAPMatchFormat, "QueryAPMatch%d");

_LIT(KExpectedNumberOfAPs, "ExpectedNumberOfAPs");

_LIT(KExpectedAPFormat, "ExpectedAP%d");

_LIT(KExpectedAPStatusFormat, "ExpectedAP%dStatus");

using namespace ConnectionServ;

// Create Connection Server

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

CCreateRConnectionServStep::CCreateRConnectionServStep(CCEsockTestBase*& aEsockTest)

:   CTe_EsockStepBase(aEsockTest)

	{

	SetTestStepName(KCreateRConnectionServStep);

	}

TVerdict CCreateRConnectionServStep::doTestStepPreambleL()

	{

	SetTestStepResult(EFail);

	if (iEsockTest==NULL)

	    iEsockTest = new (ELeave) CCEsockTestBase;

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TInt CCreateRConnectionServStep::ConfigureFromIni()

	{

	iConnectionServName.Set(KNullDesC);

	// Read in appropriate fields

	if((GetStringFromConfig(iSection, KConnectionServName, iConnectionServName) != 1)

		|| (iConnectionServName.Length() == 0))

		{

		INFO_PRINTF3(KErrString_MissingConfigFileField, &iSection, &KConnectionServName);

		return KErrNotFound;

		}

    // All ok if we got this far

    return KErrNone;

	}

TVerdict CCreateRConnectionServStep::doSingleTestStep()

	{

    TInt error = iEsockTest->CreateConnectionServer(iConnectionServName);

    if (error!=KErrNone)

        {

        INFO_PRINTF2(_L("Could not create conneciton server instance (%S)."), &iConnectionServName);

        INFO_PRINTF2(_L("Error: %d."),error);

		return EFail;

		}

	return EPass;

	}

// Connect Connection Server

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

_LIT(KTierName, "TierName");

CConnectRConnectionServStep::CConnectRConnectionServStep(CCEsockTestBase*& aEsockTest)

:   CTe_EsockStepBase(aEsockTest)

	{

	SetTestStepName(KConnectRConnectionServStep);

	}

TInt CConnectRConnectionServStep::ConfigureFromIni()

	{

	// Default the name to nothing until we know what it is

	iConnectionServName.Set(KNullDesC);

	if((GetStringFromConfig(iSection, KConnectionServName, iConnectionServName) != 1))

		{

		INFO_PRINTF3(KErrString_MissingConfigFileField, &iSection, &KConnectionServName);

		return KErrNotFound;

		}

	TBool tierIdExists = GetIntFromConfig(iSection, KConnectionServTierId, reinterpret_cast<TInt&>(iTierId));

	// If no tier id then try for a tier name instead

	if(!tierIdExists)

		{

		TPtrC tierName;

		if((GetStringFromConfig(iSection, KTierName, tierName) != 1))

			{

			INFO_PRINTF1(_L("Missing tier identifier. Require either TierName or TierId"));

			return KErrNotFound;

			}

		else

			{

			// Decode the tier name in to a tier id

			TInt error = TierNameToTierId(tierName, iTierId);

			if(error != KErrNone)

				{

				INFO_PRINTF1(_L("Unrecognised TierName field"));

				return KErrNotFound;

				}

			}

		}

    // All ok if we got this far

    return KErrNone;

	}

_LIT(KLinkTier, "LinkTier");

const TInt KLinkTierId = 0x10281DF5;

_LIT(KProtoTier, "ProtoTier");

const TInt KProtoTierId = 0x10281DF0;

_LIT(KNetworkTier, "NetworkTier");

const TInt KNetworkTierId = KAfInet; //KAfInet=0x0800

_LIT(KDummyTier, "DummyTier");

const TInt KDummyTierId = 0x1028302B;

_LIT(KWiFiTier, "WiFiTier");

const TInt KWiFiTierId = 0x1028300D;

_LIT(KMBMSTier, "MBMSTier");

const TInt KMBMSTierId = 0x2001A35B;

TInt CConnectRConnectionServStep::TierNameToTierId(const TDesC& aTierName, TUint& aTierId)

	{

	if(aTierName == KLinkTier)

		{

		aTierId = KLinkTierId;

		}

	else if (aTierName == KProtoTier)

		{

		aTierId = KProtoTierId;

		}

	else if (aTierName == KNetworkTier)

		{

		aTierId = KNetworkTierId;

		}

	else if (aTierName == KDummyTier)

		{

		aTierId = KDummyTierId;

		}

	else if (aTierName == KWiFiTier)

		{

		aTierId = KWiFiTierId;

		}

	else if (aTierName == KMBMSTier)  // MBMS_BROADCAST

		{  

		aTierId = KMBMSTierId;

		}

	else

		{

		return KErrNotFound;

		}

	return KErrNone;

	}

TVerdict CConnectRConnectionServStep::doSingleTestStep()

	{

	SetTestStepResult(EFail);

    TInt error = iEsockTest->ConnectConnectionServer(iConnectionServName, iTierId);

    if (error != KErrNone)

        {

        INFO_PRINTF2(_L("Could not connect connection server (%S)."), &iConnectionServName);

        INFO_PRINTF2(_L("Error: %d."), error);

        SetTestStepError(error);

        }

    else

    	{

    	SetTestStepResult(EPass);

    	}

	return TestStepResult();

	}

// Create Connection Server API Extension

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

CRConnectionServApiExtStep::CRConnectionServApiExtStep(CCEsockTestBase*& aEsockTest)

:   CTe_EsockStepBase(aEsockTest)

	{

	SetTestStepName(KRConnectionServApiExtStep);

	}

TInt CRConnectionServApiExtStep::ConfigureFromIni()

	{

	// Default the name to nothing until we know what it is

	iConnectionServName.Set(KNullDesC);

	if((GetStringFromConfig(iSection, KConnectionServName, iConnectionServName) != 1))

		{

		INFO_PRINTF3(KErrString_MissingConfigFileField, &iSection, &KConnectionServName);

		return KErrNotFound;

		}

	TBool tierIdExists = GetIntFromConfig(iSection, KConnectionServTierId, reinterpret_cast<TInt&>(iTierId));

    // All ok if we got this far

    return KErrNone;

	}

TVerdict CRConnectionServApiExtStep::doSingleTestStep()

	{

	SetTestStepResult(EFail);

	__UHEAP_MARK;

    RConnectionServ* connServ = iEsockTest->iConnectionServs.Find(iConnectionServName);

    if (connServ == NULL)

    	{

		return TestStepResult();

    	}

    INFO_PRINTF1(_L("RConnectionServApiExt: Opening data monitoring extension"));

 	TInt err = iExt.Open(*connServ);

    INFO_PRINTF1(_L("RConnectionServApiExt: Data monitoring extension opened"));

   	TRequestStatus tStatus;

   	TBuf8<1024> tResponseEventBuf;

    INFO_PRINTF1(_L("RConnectionServApiExt: RequestDataTransferred"));

    iExt.RequestDataTransferred(tResponseEventBuf, tStatus); 

    User::WaitForRequest(tStatus); // wait for 2 seconds (Dummy TM implementation)

    INFO_PRINTF1(_L("RConnectionServApiExt: RequestDataTransferred returned"));

    INFO_PRINTF1(_L("RConnectionServApiExt: RequestDataTransferred"));

    iExt.RequestDataTransferred(tResponseEventBuf, tStatus); 

    INFO_PRINTF1(_L("RConnectionServApiExt: CancelDataTransferredRequest"));

    iExt.CancelDataTransferredRequest();

	RTimer timer;

   	TRequestStatus timerStatus;

	timer.CreateLocal();

    timer.After(timerStatus, 1e6);

    User::WaitForRequest(tStatus, timerStatus); // if it works properly, tStatus will be signalled first

    INFO_PRINTF1(_L("RConnectionServApiExt: RequestDataTransferred returned"));

    if (tStatus != KRequestPending)

    	{

    	if (tStatus == KErrCancel)

    		{

			SetTestStepResult(EPass);

    		}

		timer.Cancel();

    	}

	timer.Close();

	iExt.Close();

	__UHEAP_MARKEND;

	return TestStepResult();

	}

// Close Connection Server

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

CCloseRConnectionServStep::CCloseRConnectionServStep(CCEsockTestBase*& aEsockTest)

:   CTe_EsockStepBase(aEsockTest)

	{

	SetTestStepName(KCloseRConnectionServStep);

	}

TInt CCloseRConnectionServStep::ConfigureFromIni()

	{

	iConnectionServName.Set(KNullDesC);

	if((GetStringFromConfig(iSection, KConnectionServName, iConnectionServName) != 1)

		|| (iConnectionServName.Length() == 0))

		{

		INFO_PRINTF3(KErrString_MissingConfigFileField, &iSection, &KConnectionServName);

		return KErrNotFound;

		}

    // All ok if we got this far

    return KErrNone;

	}

TVerdict CCloseRConnectionServStep::doSingleTestStep()

	{

    TInt error = iEsockTest->CloseConnectionServer(iConnectionServName);

    if (error != KErrNone)

        {

        INFO_PRINTF2(_L("Could not close connection server (%S)."), &iConnectionServName);

        INFO_PRINTF2(_L("Error: %d."), error);

        return EFail;

        }

	return EPass;

	}

_LIT(KAccessPointGenericParameterSet, "GenericParameterSet");

_LIT(KAccessPointParametersType, "ParametersType");

_LIT(KNone, "none");

//_LIT(KAccessPointWifiParameterSet, "WifiParameterSet");

// Connection server query base class

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

TInt CRConnectionServQueryTestStepBase::BuildQueryL(ConnectionServ::CConnectionServParameterBundle& aQueryBundle)

	{

	// Build a query from the ini settings

	// Fill in list of APs to limit scope to

	// We have zero or more AP matches to read in

	for(TInt index = 0; index < KMaxAccessPoints; index++)

		{

		TBuf<64> accessPointMatch;

		accessPointMatch.Format(KQueryAPMatchFormat, index);

		TInt accessPointId;

		// Try to read the next AP

		if((GetIntFromConfig(iSection, accessPointMatch, accessPointId) != 1))

			{

			break;

			}

		else

			{

			// Add the newly found access point to the table

			TAccessPointInfo apInfo;

			apInfo.SetAccessPoint(accessPointId);

			aQueryBundle.AddMatchConditionL(apInfo);

			}

		}

	// Fetch and parse filter specification

	TPtrC filterDes;

	TAccessPointStatusFilter filter;

	if((GetStringFromConfig(iSection, KAccessPointFilter, filterDes) == 1) && (filterDes.Length() != 0))

		{

		// We are potentially explicitly including no filter

		if(filterDes == KNone)

			{

			INFO_PRINTF1(_L("Access point filter explicitly set to none"));

			}

		else

			{

			TRAPD(error, FetchFilterL(filterDes, filter);)

			if(error != KErrNone)

				{

				INFO_PRINTF1(_L("Problem with filter syntax"));

				return KErrArgument;

				}

			// Add the filter to the bundle

			aQueryBundle.AddMatchConditionL(filter);

			}

		}

	else

		{

		INFO_PRINTF1(_L("No filter specified. No filter added to query"));

		}

	// Specify which type of parameters we want back

	TPtrC paramsType;

	if((GetStringFromConfig(iSection, KAccessPointParametersType, paramsType) == 1))

		{

		if (paramsType.CompareF(KAccessPointGenericParameterSet) == 0)

			{

			aQueryBundle.AddParameterSetToReturnL

				(XAccessPointGenericParameterSet::Type());

			INFO_PRINTF2(_L("Parameter set type:%S"), &KAccessPointGenericParameterSet);

			}

/*		else if (paramsType.CompareF(KAccessPointWifiParameterSet) == 0)

			{

			aQueryBundle.AddParameterSetToReturnL

				(XAccessPointGenericParameterSet::Type());

			aQueryBundle.AddParameterSetToReturnL

				(XAccessPointWifiParameterSet::Type());

			INFO_PRINTF3(_L("Parameter set types: %S and %S"), &KAccessPointGenericParameterSet, &KAccessPointWifiParameterSet);

			}

*/		else if (paramsType.CompareF(KNone) == 0)

			{

			INFO_PRINTF1(_L("Parameter set type set to *none*. None added to query."));

			}

		else

			{

			INFO_PRINTF1(_L("Parameter set type not recognised."));

			return KErrArgument;

			}

		}

	// Otherwise we use the generic set by default

	else

		{

		aQueryBundle.AddParameterSetToReturnL

			(XAccessPointGenericParameterSet::Type());

		}

    // All ok if we got this far

    return KErrNone;

	}

_LIT(KInvalid, "invalid");

void CRConnectionServQueryTestStepBase::FetchFilterL(

	const TDesC& aFilterDes,

	TAccessPointStatusFilter& aFetchedFilter)

	{

	// Is the filter perhaps supposed to be invalid

	if(aFilterDes == KInvalid)

		{

		aFetchedFilter = TAccessPointStatusFilter(-1);

		return;

		}

	// Otherwise parse it out from the string given

	TLex lexer;

	lexer.Assign(aFilterDes);

	TChar cCh;

	TChar rCh;

	TChar aCh;

	TChar sCh;

	if(!

		(

			( lexer.Get() == TChar('C') ) && ( cCh = lexer.Get() ) &&

			( lexer.Get() == TChar('R') ) && ( rCh = lexer.Get() ) &&

			( lexer.Get() == TChar('A') ) && ( aCh = lexer.Get() ) &&

			( lexer.Get() == TChar('S') ) && ( sCh = lexer.Get() )

		)

	)

		{

		User::Leave(KErrArgument);

		}

	TAccessPointFlagFilterValue c, r, a, s;

	c = ReadFlagFilterValueL(cCh);

	r = ReadFlagFilterValueL(rCh);

	a = ReadFlagFilterValueL(aCh);

	s = ReadFlagFilterValueL(sCh);

	aFetchedFilter.Configured(c);

	aFetchedFilter.Restricted(r);

	aFetchedFilter.Available(a);

	aFetchedFilter.Started(s);

	}

TInt CRConnectionServQueryTestStepBase::BuildExpectedResultsL(

	RArray<TExpectedAccessPointParameters>& aExpectedAPParameters,

	TInt& aNumExpectedAPs)

	{

	// Fetch the number of accesspoints expected to be returned

	if(GetIntFromConfig(iSection, KExpectedNumberOfAPs, aNumExpectedAPs) != 1)

		{		

		INFO_PRINTF3(KErrString_MissingConfigFileField, &iSection, &KExpectedNumberOfAPs);

		return KErrNotFound;

		}

	// Fetch the list of access points and their status values

	TUint specificAPCount = 0;

	for(TInt index = 1; index < KMaxAccessPoints; index++)

		{

		TBuf<64> accessPointMatch;

		accessPointMatch.Format(KExpectedAPFormat, index);

		TInt accessPointId;

		// Try to read the next AP

		if((GetIntFromConfig(iSection, accessPointMatch, accessPointId) != 1))

			{

			break;

			}

		else

			{

			// We have access point identifier

			TAccessPointInfo apInfo;

			apInfo.SetAccessPoint(accessPointId);

			// Now require expected status for the given access point identifier

			TBuf<64> expectedAPMatch;

			expectedAPMatch.Format(KExpectedAPStatusFormat, index);

			// Read in the access point status

			TPtrC apStatusBuf;

			if((GetStringFromConfig(iSection, expectedAPMatch, apStatusBuf) != 1))

			{

				INFO_PRINTF3(KErrString_MissingConfigFileField, &iSection, &expectedAPMatch);

				User::Leave(KErrNotFound);

			}

			TExpectedAccessPointStatusMask apStatusMask;

			TRAPD(error, FetchFilterL(apStatusBuf, apStatusMask));

			if(error != KErrNone)

				{

				INFO_PRINTF1(_L("Problem with result mask syntax"));

				return KErrArgument;

				}

			// Append the expected parameters to Set the expected parameters

			TExpectedAccessPointParameters apParameters(apInfo, apStatusMask);

			// Add the new parameters to a list of expected results

			aExpectedAPParameters.Append(apParameters);

			}