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

// defines test class: CTextModeTestPostBodyChunks

// 

//

#include "T_PostBodyChunks.h"

// User include

#include "csrvaddrval.h"

const TInt KMilliSeconds = 1000000;

// Constants used in CTextModeTestPostBodyChunks test

_LIT8(KHttpPostBodyChunksUrl,	"http://WapTestIP/perl/dumpform.pl");

_LIT8(KHttpPostBodyChunk1, 		"abc=def&ghi=jkl&");

_LIT8(KHttpPostBodyChunk2, 		"mno=pqr&stu=vwx&");

_LIT8(KHttpPostBodyChunk3, 		"y=z");

// CTextModeTestPostBodyChunks-----------------------------------

/**

	This function is called to create a new instance of the class 

	CTextModeTestCookies

	@param aIniSettingsFile	  The script file that holds the sections

							  from which the value has to be retrieved

	@leave 					  KErrNoMemory if there is insufficient memory

*/

CTextModeTestPostBodyChunks* CTextModeTestPostBodyChunks::NewL(CScriptFile* aIniSettingsFile)

	{

	CTextModeTestPostBodyChunks* self = new(ELeave) CTextModeTestPostBodyChunks(aIniSettingsFile);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

	Destructor

*/

CTextModeTestPostBodyChunks::~CTextModeTestPostBodyChunks()

	{

	}

void CTextModeTestPostBodyChunks::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)

	{

	switch (aEvent.iStatus)

		{

		case THTTPEvent::EGotResponseHeaders:

			{

			// HTTP response headers have been received

			//iEngine->Utils().LogIt(_L("<Got response headers>"));

			DumpRespHeaders(aTransaction);

			} break;

		case THTTPEvent::ESubmit:

			{

			} break;

		case THTTPEvent::EGotResponseBodyData:

			{

			// Some (more) body data has been received (in the HTTP response)

			//iEngine->Utils().LogIt(_L("<Got a chunk of data>"));

			DumpResponseBody(aTransaction);

			} break;

		case THTTPEvent::EResponseComplete:

			{

			// The transaction's response is complete

			iEngine->Utils().LogIt(_L("<Transaction Complete>"));

			} break;

		case THTTPEvent::ESucceeded:

			{

			iEngine->Utils().LogIt(_L("<Transaction validated successfully>"));

			CActiveScheduler::Stop();

			} break;

		case THTTPEvent::EFailed:

			{

			iEngine->Utils().LogIt(

				_L("<Transaction NOT validated successfully>"));

			iFailureError = KErrTestFailed;

			CActiveScheduler::Stop();

			} break;

		case THTTPEvent::EUnrecoverableError:

			{

			iEngine->Utils().LogIt(_L("<Test failed unrecoverably>"));

			iFailureError = KErrTestFailed;

			} break;

		default:

			{

			iEngine->Utils().LogIt(_L("<unrecognised event> %d"), aEvent.iStatus);

			if (aEvent.iStatus < 0)

				{

				iFailureError = aEvent.iStatus;

				// Special case for doing heap-failure testing only - in some 

				// failure circumstances, the outstanding socket read/writes 

				// complete with a time out

				if ((iLeakTests > 0) && (iFailureError == KErrTimedOut))

					{

					iFailureError = KErrTestFailed;

					}

				CActiveScheduler::Stop();

				}

			} 

			break;

		}

	}

TInt CTextModeTestPostBodyChunks::MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& aEvent)

	{

	iEngine->Utils().LogIt(

		_L("\nMHFRunL left: error code %d on transaction ID=%d for event %d\n"),

		aError, aTransaction.Id(), aEvent.iStatus);

	return KErrNone;

	}

/**

	This function is called to get the next chunk of data.

	@param aDataChunk	The pointer which holds the next data chunk.

*/

TBool CTextModeTestPostBodyChunks::GetNextDataPart(TPtrC8& aDataChunk)

	{

	TBool retVal = EFalse;

	switch (iReqBodyChunkCount)

		{

		case 0:

			{

			aDataChunk.Set(KHttpPostBodyChunk1());

			} break;

		case 1:

			{

			aDataChunk.Set(KHttpPostBodyChunk2());

			} break;

		case 2:

			{

			aDataChunk.Set(KHttpPostBodyChunk3());

			retVal = ETrue;

			} break;

		}

	iReqBodyChunkCount++;

	return retVal;

	}

/**

	Set timer to fire when we want to signal the availability of the next 

	chunk, provided we've not finished

*/

void CTextModeTestPostBodyChunks::ReleaseData()

	{

	if (iReqBodyChunkCount < 3)

		{

		iReleaseTimer->After(KMilliSeconds);

		}

	}

TInt CTextModeTestPostBodyChunks::OverallDataSize()

	{

	return (KHttpPostBodyChunk1().Length() + KHttpPostBodyChunk2().Length() + KHttpPostBodyChunk3().Length());

	}

const TDesC& CTextModeTestPostBodyChunks::TestName()

	{

	_LIT(KHeaderTestName,"CTextModeTestPostBodyChunks");

	return KHeaderTestName;

	}

/**

	This function is called to initiate the tests.

	It may leave with one of the system-wide error codes.

*/

void CTextModeTestPostBodyChunks::DoRunL()

	{

	// Open the HTTP session

	iSession.OpenL();

	CleanupClosePushL(iSession);

	RStringPool strP = iSession.StringPool();

	// Open a POST transactions, specifying this object as the request body 

	// data supplier

	TUriParser8 up;

	HBufC8* newUrl8 = TSrvAddrVal::ReplaceHostNameL(KHttpPostBodyChunksUrl(), iIniSettingsFile);

	CleanupStack::PushL(newUrl8);

	TPtr8 newUrlPtr8 = newUrl8->Des();

	up.Parse(newUrlPtr8);

	iTransaction = iSession.OpenTransactionL(up, *this, strP.StringF(HTTP::EPOST,RHTTPSession::GetTable()));

	RHTTPRequest rq = iTransaction.Request();

	rq.SetBody(*this);

	RHTTPHeaders hdr = rq.GetHeaderCollection();

	THTTPHdrVal length(OverallDataSize());

	hdr.SetFieldL(strP.StringF(HTTP::EContentLength,RHTTPSession::GetTable()), length);

	THTTPHdrVal contType(strP.StringF(HTTP::EApplicationXWwwFormUrlEncoded, RHTTPSession::GetTable()));

	hdr.SetFieldL(strP.StringF(HTTP::EContentType, RHTTPSession::GetTable()), contType);

	// Create the delayed notifier

	iReleaseTimer = CDelayedBodyDataNotifier::NewL(iTransaction);

	CleanupStack::PushL(iReleaseTimer);

	CActiveScheduler::Add(iReleaseTimer);

	// Submit the transaction

	iTransaction.SubmitL();

	iFailureError = KErrNone;

	CActiveScheduler::Start();

	// Get the completion code and inform the engine.  Anything other than 

	// HTTP/200 status is a failure for this test.

	iEngine->SetCurrentStatusCode(iTransaction.Response().StatusCode());

	iExpectedStatusCode = 200;

	// Close anything opened

	CleanupStack::PopAndDestroy(3, &iSession); // and iReleaseTimer, newUrl8;

	// Check for failure error codes caught in MHFRunL

	User::LeaveIfError(iFailureError);

	}

TInt CTextModeTestPostBodyChunks::RunError(TInt aErr)

	{

	iEngine->Utils().LogIt(_L("\nTest failed with error code %d\n"), aErr);

	return KErrNone;

	}

void CTextModeTestPostBodyChunks::DoCancel()

	{

	iReleaseTimer->Cancel();

	}

CTextModeTestPostBodyChunks::CTextModeTestPostBodyChunks(CScriptFile* aIniSettingsFile) :

	iIniSettingsFile(aIniSettingsFile)

	{

	}

/**

	This constructor is called in the NewL function and used by the class to

	construct self.  Currently this has no functionality.  In future this 

	constructor can be used.

*/

void CTextModeTestPostBodyChunks::ConstructL()

	{

	}

CTextModeTestPostBodyChunks::CDelayedBodyDataNotifier*

CTextModeTestPostBodyChunks::CDelayedBodyDataNotifier::NewL(RHTTPTransaction aTrans)

	{

	CDelayedBodyDataNotifier* self = new(ELeave) CDelayedBodyDataNotifier(aTrans);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTextModeTestPostBodyChunks::CDelayedBodyDataNotifier::CDelayedBodyDataNotifier(RHTTPTransaction aTrans)

	: 	CTimer(EPriorityStandard), iTrans(aTrans)

	{

	}

void CTextModeTestPostBodyChunks::CDelayedBodyDataNotifier::RunL()

	{

	iTrans.NotifyNewRequestBodyPartL();

	}