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

// CStepOne derived implementation

// 

//

/**

 @file

 @internalComponent 

*/

#include <e32base.h>

#include <sacls.h>

#include "WapBoundWDPSteps.h"

#include "WapStackSuiteDefs.h"

#include <etel.h>

#include <es_wsms.h>

#include <simtsy.h>

#include <wapmsgerr.h>

#include <ecom/ecom.h>

CBoundWDPStepBase::CBoundWDPStepBase()

/**

* Constructor

*/

	{

	}

CBoundWDPStepBase::~CBoundWDPStepBase()

/**

* Destructor

*/

	{

	if(iImp) 

		{

		UnloadInterface();

		}

	}

// Load CWapBoundDatagramService Interface 

CWapBoundDatagramService* CBoundWDPStepBase::LoadInterface()

	{

	TInt trapValue;

	CWapBoundDatagramService* implementation = NULL;

	// UID {0x101FBB37} - SWS implementation

	TUid KInterfaceUid = {0x101FBB37}; 	

	INFO_PRINTF2(_L("Calling new NewL(0x%08X) method"), KInterfaceUid);

	TRAP(trapValue, implementation = CWapBoundDatagramService::NewL(KInterfaceUid));

	if(!trapValue)

		{

		INFO_PRINTF2(_L("Interface is loaded: implementation.addr = 0x%08x"), implementation);

		return implementation;

		}

	else return NULL;

	}

void CBoundWDPStepBase::UnloadInterface()

	{

	INFO_PRINTF2(_L("Interface at implementation.addr = 0x%08x is deleted"), iImp);

	delete iImp;

	iImp = NULL;

	REComSession::FinalClose();	

	}

CBoundWDPStep_1::CBoundWDPStep_1()

/**

* Constructor

*/

	{

	}

CBoundWDPStep_1::~CBoundWDPStep_1() 

/**

* Destructor

*/

	{

	}

TVerdict CBoundWDPStep_1::doTestStepL()

/** 

* Load and destroy BoundDatagtamService interface implementation

* Two different methods are used NewL() and NewL(TUid InterfaceUid)

* @return - TVerdict code

*/

	{

	// CWapBoundDatagramService

	INFO_PRINTF1(_L("CreateImplementation - CWapBoundDatagramService"));

	INFO_PRINTF1(_L("Calling old NewL() method"));

	SetTestStepResult(EFail);

	TInt trapValue(0); 

	TRAP(trapValue, iImp = CWapBoundDatagramService::NewL());

	if(!trapValue)

		{

		INFO_PRINTF2(_L("Interface is loaded: implementation.addr = 0x%08x"), iImp);

		UnloadInterface();

		iImp = LoadInterface();

		if(iImp)

			{

			INFO_PRINTF1(_L("CreateImplementation - OK"));

			SetTestStepResult(EPass);

			UnloadInterface();

			}

		}

	return TestStepResult();

	}

CBoundWDPStep_2::CBoundWDPStep_2()

/**

* Constructor

*/

	{

	}

CBoundWDPStep_2::~CBoundWDPStep_2()

/**

* Destructor

*/

	{

	}

TVerdict CBoundWDPStep_2::doTestStepL()

/**

* Test Connect methoths

* @return - TVerdict code

*

*/

	{

	INFO_PRINTF1(_L("BOUND-WDP: Connect"));

	if(TestStepResult() == EPass )

		{

		SetTestStepResult(EFail);

		iImp = LoadInterface();

		if(iImp)

			{

			TInt bearer, port;

			TInt error = KErrNone;

			TBool reconnect = EFalse;

			TBool delay = EFalse;

			SetLastError(KErrNone);

			if(GetIntFromConfig(ConfigSection(),KWapBearer, bearer)) iBearer = (Wap::TBearer)bearer;

			if(GetIntFromConfig(ConfigSection(),KWapLocalPort, port)) iLocalPort = (Wap::TPort)port;

			if(GetIntFromConfig(ConfigSection(),KWapExError, error)) SetExpectedError(error);

			if(GetBoolFromConfig(ConfigSection(),KWapReconnect, reconnect)) iReconnect = reconnect;

			if(GetBoolFromConfig(ConfigSection(),KWapDelayPortClosure, delay)) iDelayPortClosure = delay;

			TInt checkValue = 0;

			if(UseSimTsy())

				{

				GetIntFromConfig(ConfigSection(), KWapSIMTSYState, iSimTsyState);

				User::LeaveIfError(RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyTestNumber, iSimTsyState));

				// double check that base did set it since this is the first place we try setting it in the harness

				RProperty::Get(KUidPSSimTsyCategory, KPSSimTsyTestNumber, checkValue);

				__ASSERT_ALWAYS(checkValue == iSimTsyState,User::Panic(KWapStackSuitePanic, EDataCorrupt));

				} 

			User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidPhonePwr.iUid, ESAPhoneOn));

			// double check

			RProperty::Get(KUidSystemCategory, KUidPhonePwr.iUid, checkValue);

			__ASSERT_ALWAYS(checkValue == ESAPhoneOn,User::Panic(KWapStackSuitePanic, EDataCorrupt));

			SetState(EConnect);

			iControl->ReStart();

			ShowConnectionInfo();

			// Start state machine

			StartScheduler();

			UnloadInterface();

			}

		}

	return TestStepResult();

	}

TInt CBoundWDPStep_2::CallStateMachine()

	{

	TInt err = KErrNone;

	INFO_PRINTF2(_L("CallStateMachine: step [%d]"), State());

	switch(iState)

		{

		case EConnect:

			INFO_PRINTF1(_L("EConnect"));

			err = iImp->Connect(iBearer, iLocalPort);

			INFO_PRINTF2(_L("Connection completed with code = %d"), err);

			if( err == KErrNone)

				{

				if(iReconnect)

					{

					INFO_PRINTF1(_L("Second connect"));

					iControl->ReStart();

					break;

					}

				}

			SetState(EFinish);

			SetLastError(err);

			iControl->ReStart();

			break;

		case EFinish:

			// it's necessary to delay port closure, let the other concurrent test step

			// can fail opening the same port with expected error EPortAlreadyBound (-5498)

			if (iDelayPortClosure)

				User::After(5000000);

			INFO_PRINTF1(_L("EFinish"));

			if(GetLastError() == GetExpectedError()) SetTestStepResult(EPass);

			else SetTestStepResult(EFail);

			SetState(EIdle);

			// End of state machine

			StopScheduler();

			break;

		case EIdle:

		default:

			INFO_PRINTF2(_L("Error: bad state EIdle or unknown [%d]"), State());

			SetTestStepResult(EFail);

			// End of state machine

			StopScheduler();

			break;

		}

	return (0);

	}

CBoundWDPStep_3::CBoundWDPStep_3() 

/**

* Constructor

*/

	{

	}

CBoundWDPStep_3::~CBoundWDPStep_3() 

/**

* Destructor

*/

	{

	}

TVerdict CBoundWDPStep_3::doTestStepL()

/*

* Test the CBoundWDP APIs in unconnected state.

*/

	{

	INFO_PRINTF1(_L("BoundWDP. Requests without connection"));

	// check preamble result

	TVerdict verdict = TestStepResult();

	if (verdict==EPass)

		{

		TInt err, ret;

		iImp = LoadInterface();

		if (!iImp)

			{

			ERR_PRINTF1(_L("Unable to load BoundWDP Interface"));

			verdict = EFail;

			}

		else

			{

			GetIntFromConfig(ConfigSection(),KWapExError,(TInt&)iExError);

			ShowConnectionInfo();

			TBuf8<100> buf;

			err = iImp->SendTo(iRemoteHost, iRemotePort, buf, iBearer);

			TRAP(ret, TEST_CHECKL(err, iExError, _L("SendTo Fails not as expected")))

			if (ret) 

				{

				verdict = EFail;

				}

			else

				{

				TPckg<TUint16> aDataSizePckg(0);

				TRequestStatus reqStatus;

				iImp->AwaitRecvDataSize(aDataSizePckg, reqStatus);

				User::WaitForRequest(reqStatus);

				TRAP(ret, TEST_CHECKL(reqStatus.Int(), iExError, _L("AwaitRecvDataSize Fails not as expected")))

				if (ret) 

					{

					verdict = EFail;

					}

				else

					{

					TBuf8<100> buf;

					TBool truncated;

					TUint32 timeout=0;

					iImp->RecvFrom(iRecvRemoteHost, iRecvRemotePort, buf, truncated, reqStatus, timeout);

					User::WaitForRequest(reqStatus);

					TRAP(ret, TEST_CHECKL(reqStatus.Int(), iExError, _L("RecvFrom Fails not as expected")))

					if (ret) 

						{

						verdict = EFail;

						}

					else

						{

						Wap::TPort aPort;

						err=iImp->GetLocalPort(aPort);

						TRAP(ret, TEST_CHECKL(err, iExError, _L("GetLocalPort Fails not as expected")))

						if (ret) 

							{

							verdict = EFail;

							}

						else

							{

							HBufC8* localHost;

							err=iImp->GetLocalAddress(localHost);

							TRAP(ret, TEST_CHECKL(err, iExError, _L("GetLocalAddress Fails not as expected")))

							if (ret) 

								{

								verdict = EFail;

								}

							else

								{

								TUint16 maxSize, nominalSize;

								err=iImp->GetDatagramSizes(maxSize, nominalSize);

								if (err)

									{

									verdict = EFail;

									}

								else

									{

									err=iImp->GetBearer(iBearer);

									TRAP(ret, TEST_CHECKL(err, iExError, _L("GetBearer Fails not as expected")))

									if (ret)

										{

										verdict = EFail;

										}

									}

								}

							}

						}

					}

				}

			UnloadInterface();

			}

		}

	if (verdict==EPass)

		{

		INFO_PRINTF1(_L("BoundWDP. Requests Fail as expected"));

		}

	SetTestStepResult(verdict);

	return TestStepResult();

	}

TInt CBoundWDPStep_3::CallStateMachine()

	{

	return (0);

	}

CBoundWDPStep_4::CBoundWDPStep_4() 

/**

* Constructor

*/

	{

	}

CBoundWDPStep_4::~CBoundWDPStep_4() 

/**

* Destructor

*/

	{

	}

TVerdict CBoundWDPStep_4::doTestStepL()

/** 

*/

	{

	INFO_PRINTF1(_L("BOUND-WDP: Connect-Send-Await-Receive"));

	if(TestStepResult() == EPass )

		{

		SetTestStepResult(EFail);

		iImp = LoadInterface();

		if(iImp)

			{

			SetLastError(KErrNone);

			TInt bearer, port, bufLen;

			TInt error = KErrNone;

			TPtrC data, remote_host;

			if(GetIntFromConfig(ConfigSection(),KWapBearer, bearer))

				{

				iBearer = static_cast<Wap::TBearer>(bearer);

				}

			if(GetIntFromConfig(ConfigSection(),KWapLocalPort, port))

				{

				iLocalPort = static_cast<Wap::TPort>(port);

				}

			if(GetStringFromConfig(ConfigSection(), KWapRemoteHost, remote_host))

				{

				iRemoteHost.Copy(remote_host);

				}

			if(GetIntFromConfig(ConfigSection(),KWapRemotePort, port))

				{

				iRemotePort = static_cast<Wap::TPort>(port);

				}

			if(GetIntFromConfig(ConfigSection(),KWapExError, error))

				{

				SetExpectedError(error);

				}

			GetIntFromConfig(ConfigSection(), KWapExError2, iExError2);

			GetBoolFromConfig(ConfigSection(), KAwaitLengthCancel, iAwaitLengthCancel);

			GetBoolFromConfig(ConfigSection(), KMiddleCancel, iMiddleCancel);

			GetBoolFromConfig(ConfigSection(), KMultiReadCancel, iMultiReadCancel);

			GetBoolFromConfig(ConfigSection(), KAwaitLengthTwice, iAwaitLengthTwice);

			if(GetIntFromConfig(ConfigSection(),KWapWdpBufLength, bufLen))

				{

				iWdpRecvBufLength=static_cast<TUint16>(bufLen);

				iRecvBuffPtr = HBufC8::NewL(iWdpRecvBufLength);

				}

			error = GetStringFromConfig(ConfigSection(),KWapData, data);

			if(!error)

				{

				User::Leave(error);

				}

			iSendBuffPtr = HBufC8::NewL(data.Length());

			TPtr8 tmp = iSendBuffPtr->Des();

			tmp.Copy(data);

			if(UseSimTsy())

				{

				GetIntFromConfig(ConfigSection(), KWapSIMTSYState, iSimTsyState);

				User::LeaveIfError(RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyTestNumber, iSimTsyState));

				}

			User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidPhonePwr.iUid, ESAPhoneOn));

			SetState(EConnect);

			iControl->ReStart();

			ShowConnectionInfo();

			// Start state machine

			StartScheduler(); 

			UnloadInterface();

			}

		}

	return TestStepResult();

	}

TInt CBoundWDPStep_4::CallStateMachine()

	{

	TVerdict verdict = EFail;

	TInt err = KErrNone;

	TInt activate = 0;

	INFO_PRINTF2(_L("CallStateMachine: state [%d]"), State());

	switch(iState)

		{

		case EConnect:

			INFO_PRINTF1(_L("EConnect"));

			err = iImp->Connect(iBearer, iLocalPort);

			INFO_PRINTF2(_L("Connection completed with code = %d"), err);

			if( err == KErrNone)

				{

					if(iBearer != Wap::EIP)

						{

						TRAP(err, WaitForInitializeL());

						}

					if(iSendBuffPtr->Length())

						{

						INFO_PRINTF1(_L("Data to send"));

						DumpBuf(iSendBuffPtr->Des());

						}

				err = iImp->SendTo(iRemoteHost, iRemotePort, iSendBuffPtr->Des(), iBearer);

				INFO_PRINTF2(_L("SendTo completed with code = %d"), err);

				if(err == KErrNone) 

					{	

					SetState(EAwaitSize);

					}

				else 

					{	

					SetState(EFinish);

					}

				}

			else 

				{

				SetState(EFinish);

				}

			SetLastError(err);

			iControl->ReStart();

			break;

		case EAwaitSize:

			INFO_PRINTF1(_L("EAwaitSize"));

			iImp->AwaitRecvDataSize(iLength, *iStatus);

			activate = 1;

			if (!iAwaitLengthCancel)

				{

				SetState(EReceive);

				}

			else

				{

				INFO_PRINTF1(_L("Cancel Receive in AwaitSize state"));

				iImp->CancelRecv();

				SetState(EFinish);

				}

			break;

		case EReceive:

			INFO_PRINTF1(_L("EReceive"));

			if(iStatus->Int()!=KErrNone) 

				// AwaitSize failed

				{

				INFO_PRINTF1(_L("AwaitSize failed"));

				SetLastError(iStatus->Int());

				iControl->ReStart();

				SetState(EFinish);

				}

			else

				{	

				INFO_PRINTF2(_L("AwaitSize returned - %d"),iLength());

				if (!iAwaitLengthTwice)

					{

					if (iRecvBuffPtr==NULL)

						{

						TInt len=iLength();

						TRAP(err, iRecvBuffPtr = HBufC8::NewL(len))

							if (err!=KErrNone)

								{

								SetLastError(err);

								iControl->ReStart();

								SetState(EFinish);