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

// CBoundCLPushStep_xyz derived implementations

// 

//

/**

 @file

 @internalComponent

*/

#include "WapBoundCLPushSteps.h"

#include "WapStackSuiteDefs.h"

#include <simtsy.h>

#include <wapmsgerr.h>

#include <ecom/ecom.h>

CBoundCLPushStepBase::CBoundCLPushStepBase()

/**

* Constructor

*/

	{

	}

CBoundCLPushStepBase::~CBoundCLPushStepBase()

/**

* Destructor

*/

	{

	if(iImp) 

		{

		UnloadInterface();

		}

	}

// Load CWapBoundCLPushService Interface 

CWapBoundCLPushService* CBoundCLPushStepBase::LoadInterface()

	{

	TInt trapValue;

	CWapBoundCLPushService* implementation = NULL;

	// UID {0x101FBB39} - SWS implementation

	TUid KInterfaceUid = {0x101FBB39}; 	

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

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

	if(!trapValue)

		{

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

		return implementation;

		}

	else return NULL;

	}

void CBoundCLPushStepBase::UnloadInterface()

	{

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

	delete iImp;

	iImp = NULL;

	REComSession::FinalClose();

	}

CBoundCLPushStep_1::~CBoundCLPushStep_1()

/**

* Destructor

*/

	{

	}

CBoundCLPushStep_1::CBoundCLPushStep_1()

/**

* Constructor

*/

	{

	}

TVerdict CBoundCLPushStep_1::doTestStepL()

/**

* @return - TVerdict code

* Override of base class pure virtual

* Our implementation only gets called if the base class doTestStepPreambleL() did

* not leave. That being the case, the current test result value will be EPass.

*/

	{

	//

	// CWapBoundCLPushService

	// 

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

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

	TInt trapValue; 

	SetTestStepResult(EFail);

	TRAP(trapValue, iImp = CWapBoundCLPushService::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();

	}

CBoundCLPushStep_2::CBoundCLPushStep_2()

/**

* Constructor

*/

	{

	}

CBoundCLPushStep_2::~CBoundCLPushStep_2() 

/**

* Destructor

*/

	{

	}

TVerdict CBoundCLPushStep_2::doTestStepL()

/** 

* Test Connect methoths 

* @return - TVerdict code

* 

*/

	{

	INFO_PRINTF1(_L("BOUNDCL-PUSH: Testing Connect"));

	if(TestStepResult() == EPass )

		{

		SetTestStepResult(EFail);

		iImp = LoadInterface();

		if(iImp)

			{

			TInt bearer, port;

			TInt error	= KErrNone;

			TBool secure= EFalse;

			TBool reconnect= EFalse;

			SetLastError(KErrNone);

			TBool delay = EFalse;

			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(), KWapSecure, secure)) iSecure = secure;

			if(GetBoolFromConfig(ConfigSection(),_L("Reconnect"), reconnect)) iReconnect = reconnect;

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

			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();

			StartScheduler();

			UnloadInterface();

			}

		}

	return TestStepResult();

	}

TInt CBoundCLPushStep_2::CallStateMachine()

	{

	TInt err = KErrNone;

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

	switch(iState)

		{

		case EConnect:

			INFO_PRINTF1(_L("EConnect"));

			err = iImp->Connect(iBearer, (Wap::TPort)iLocalPort, iSecure);

			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); 

			StopScheduler();

			break;

		case EIdle:

		default:

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

			SetTestStepResult(EFail);

			StopScheduler();

			break;

		}

	return (0);

	}

CBoundCLPushStep_3::CBoundCLPushStep_3()

/**

* Constructor

*/

	{

	}

CBoundCLPushStep_3::~CBoundCLPushStep_3() 

/**

* Destructor

*/

	{

	}

TVerdict CBoundCLPushStep_3::doTestStepL()

/*

* Test the BoundCLPush APIs in unconnected state.

*/

	{

	INFO_PRINTF1(_L("BoundCLPush. 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 BoundCLPush Interface"));

			verdict = EFail;

			}

		else

			{

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

			ShowConnectionInfo();

			TRequestStatus reqStatus;

			iImp->AwaitPush(iRecvHeadersBuf, iRecvBodyBuf, iTransactionIdPckg, reqStatus);

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

				if (ret) 

					verdict = EFail;

				else

					{

					Wap::TPort port;

					err=iImp->GetLocalPort(port);

					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

									{

									err=iImp->GetBearer(iBearer);

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

										if (ret) 

											verdict = EFail;

										else

											{

											HBufC8* host;

											err=iImp->GetServerAddress(host);

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

												if (ret) 

													verdict = EFail;

											}

									}

							}

					}

				UnloadInterface();

			}

		}

	if (verdict==EPass)

		{

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

		}

	SetTestStepResult(verdict);

	return TestStepResult();

	}

TInt CBoundCLPushStep_3::CallStateMachine()

	{

	return (0);

	}

CBoundCLPushStep_4::CBoundCLPushStep_4()

/**

* Constructor

*/

	{

	}

CBoundCLPushStep_4::~CBoundCLPushStep_4() 

/**

* Destructor

*/

	{

	}

TVerdict CBoundCLPushStep_4::doTestStepL()

/** 

* Test receiving PDU data over UDP

* The test is run concurently with CBoundCLPushStep_9 test. CBoundCLPushStep_4 waits for push message whilst 

* CBoundCLPushStep_9 sends a push message over UDP using loopback. 

* The test pair is used to test two cases (dependent on configuration read for CBoundCLPushStep_9):

* - sending PDU data that is smaller than the allocated buffer on the receiving side (<=1024)

* - sending PDU data that is larger than the allocated buffer on the receiving side and needs reallocation (>1024)

* @return - TVerdict code

* 

*/

	{

	INFO_PRINTF1(_L("BOUND-CLPUSH: Connect-AwaitPush"));

	INFO_PRINTF1(_L("Receiving PDU over UDP from a concurrent test... "));

	if(TestStepResult() == EPass )

		{

		SetTestStepResult(EFail);

		iImp = LoadInterface();

		if(iImp)

			{

			SetLastError(KErrNone);

			TInt bearer, port;

			TInt error = KErrNone;

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

				{

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

				}

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

				{

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

				}

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

				{

				SetExpectedError(error);

				}

			GetBoolFromConfig(ConfigSection(), KMiddleCancel, iMiddleCancel);

			GetBoolFromConfig(ConfigSection(), KMultiReadCancel, iMultiReadCancel);

			TInt headerLength, bufLength; 

			if(GetIntFromConfig(ConfigSection(),KWapWSPRecvHeaderLength, headerLength))

				{

				iHeaderRecvBufLength=static_cast<TUint16>(headerLength);

				}

			if(GetIntFromConfig(ConfigSection(),KWapWSPRecvBodyLength, bufLength))

				{

				iBodyRecvBufLength=static_cast<TUint16>(bufLength);

				}

			iRecvHeaders = HBufC8::NewL(iHeaderRecvBufLength);

			iRecvBody = HBufC8::NewL(iBodyRecvBufLength);

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

			if(UseSimTsy())

				{

				GetIntFromConfig(ConfigSection(),KWapSIMTSYState, iSimTsyState);

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

				}

			SetState(EConnect);

			iControl->ReStart();

			ShowConnectionInfo();

			StartScheduler();

			delete iRecvBody;

			iRecvBody=NULL;

			delete iRecvHeaders;

			iRecvHeaders=NULL;

			UnloadInterface();

			}

		}

	return TestStepResult();

	}

TInt CBoundCLPushStep_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, EFalse);

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

			if( err == KErrNone)

				{

				if(iBearer != Wap::EIP)

					{

					TRAP(err, WaitForInitializeL());

					}

				iRecvHeadersBuf.Set(iRecvHeaders->Des());

				iRecvBodyBuf.Set(iRecvBody->Des());

				iImp->AwaitPush(iRecvHeadersBuf, iRecvBodyBuf, iTransactionIdPckg, *iStatus);

				INFO_PRINTF1(_L("Start AwaitingPush....."));

				activate = 1;

				if (!iMiddleCancel)

					{

					SetState(EAwaitPush);

					}

				else

					{

					INFO_PRINTF1(_L("Cancel AwaitPush"));

					iImp->CancelAwaitPush();

					SetState(EFinish);

					}

				}

			else 

				{

				SetState(EFinish);

				iControl->ReStart();

				}

			SetLastError(err);

			break;

		case EAwaitPush:

			INFO_PRINTF1(_L("EAwaitPush"));

			if(iStatus->Int() != KErrNone && iStatus->Int()!=Wap::EMoreData) 

				// AwaitPush failed

				{

				INFO_PRINTF1(_L("AwaitPush failed"));

				SetLastError(iStatus->Int());

				SetState(EFinish);

				iControl->ReStart();

				}

			else

				{

				iMaxWspHeaderRecvBuffer.Append(iRecvHeadersBuf);

				iMaxWspDataRecvBuffer.Append(iRecvBodyBuf);

				if (iStatus->Int()==Wap::EMoreData)

					{

					iImp->AwaitPush(iRecvHeadersBuf, iRecvBodyBuf, iTransactionIdPckg, *iStatus);

					activate = 1;

					if (!iMultiReadCancel)

						{

						SetState(EAwaitPush);

						}

					else

						{

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

						iImp->CancelAwaitPush();

						SetState(EFinish);

						}					

					}

				else

					{

					SetLastError(iStatus->Int());

					iControl->ReStart();

					SetState(EFinish);

					}

				}

			break;

		case EFinish:

			INFO_PRINTF1(_L("EFinish"));

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

				{

				SetLastError(iStatus->Int());

				}

			verdict = (GetLastError() == GetExpectedError())?EPass:EFail;

			if (verdict==EPass && !iMiddleCancel && !iMultiReadCancel)

				{

				iImp->CancelAwaitPush();

				INFO_PRINTF1(_L("Headers:"));

				DumpBuf(iMaxWspHeaderRecvBuffer);

				INFO_PRINTF1(_L("Body"));

				DumpBuf(iMaxWspDataRecvBuffer);

				if (verdict==EPass)

					{

					HBufC8* buf;

					iImp->GetServerAddress(buf);

					verdict = (buf->Match(iRemoteHost)!=KErrNotFound)?EPass:EFail;

					delete buf;

					}

				if (verdict==EPass)

					{

					Wap::TPort port;

					iImp->GetLocalPort(port);

					verdict = (port == iLocalPort)?EPass:EFail;

					}

				if (verdict==EPass)

					{

					Wap::TBearer bearer;

					iImp->GetBearer(bearer);

					verdict = (bearer == iBearer)?EPass:EFail;

					}

				if (verdict==EPass)

					{

					//This test can not perform.

					HBufC8* buf;

					iImp->GetLocalAddress(buf);

					delete buf;

					}