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

//

#include <e32std.h>

#include "t_filters.h"

#include <uri8.h>

_LIT8(KPost, "POST");

// Numbers in brackets are indexes (Filter result numbers). Other

// numbers are event numbers.

TInt sessionCallOrder[] = {	100005, 100003, 100002, //(0) 100005 UID 2 Outgoing

							100003, 100001,			//(3) 100005 UID 1 Outgoing

							100004, 100003, 100001,	//(5) 100004 UID 1 Outgoing

							100004,	100003, 100002,	//(8) 100004 UID 2 Outgoing

							100002, 100003, 100005, //(11) 100005 UID 2 Incoming

							100001, 100003,			//(14) 100005 UID 1 Incoming

							100001, 100003, 100004,  //(16) 100004 UID 1 Incoming

							100002, 100003, 100004  //(19) 100004 UID 2 Incoming

							};

TInt callOrder[] = {4,3,2,1,//(0) 33 Outgoing

					4,2,1, //(4) 22 Outgoing

					4,2,1,//(7). 22,KHTTPMatchAnyEventUid Outgoing

					4,3,2,1, //(10) 33 Outgoing

					2,3,4,5,//(14). Sent from 4th call to Filter 1.33 Incoming

					2,4,5, //(18) 22 Incoming

					2,4,5,//(21) 22,KHTTPMatchAnyEventUid Incoming

					4,2,1, // (24) Cancel (This doesn't happen but it should)

					4,2,1, //(27) Delete ***********

					6,4,3,2,1,//(30) 33 Outgoing Client

					6,// (35)33 Outgoing. Filter 6 deletes itself

					6,4,2,1,//(36) Cancel

					6,4,2,1, // (40) Delete

					6, // (44) Delete from RunError.

					6,4,2,1, // (45) Cancel

					6,4,2,1, // (49) Delete

					6,4,3,2,1, // (53) 33 Status match: response absent.

					6,7,4,3,2,1, // (58) Filter matching due to status

					6,4,3,2,1,// (64) Status match. Wrong status

					6,4,2,1,// (69) Cancel

					6,4,2,1,// (73) Delete

					6,4,3,2,1,// (77) Header absent

					6,8,4,3,2,1,// (82)

					6,8,4,2,1,// 88

					6,4,2,1, 6,4,2,1}; // 93 Cancel, close

TInt callCount = 0;

TInt sessionCallCount = 0;

class CQuitObject : public CActive

	{

public:

	static CQuitObject* NewL(TInt aCount,CHTTPFilterTest* aTest, TBool aTestingSessionEvents = EFalse);

	~CQuitObject();

protected:

	virtual void RunL();

	virtual void DoCancel();

private:

	inline CQuitObject();

	TInt iCount;

	CHTTPFilterTest* iTest;

	TBool iTestingSessionEvents;

	};

CQuitObject* CQuitObject::NewL(TInt aCount, CHTTPFilterTest* aTest, TBool aTestingSessionEvents)

	{

	CQuitObject* that = new (ELeave) CQuitObject;

	that->iTestingSessionEvents = aTestingSessionEvents;

	that->iCount = aCount;

	that->iTest = aTest;

	CActiveScheduler::Add(that);

	that->SetActive();

	TRequestStatus* r = &that->iStatus;

	User::RequestComplete(r, 0);

	return that;

	}

CQuitObject::~CQuitObject()

	{

	Cancel();

	}

CQuitObject::CQuitObject()

		: CActive(EPriorityIdle)

	{

	}

void CQuitObject::RunL()

	{

	TInt count = iTestingSessionEvents ? sessionCallCount : callCount;

	iTest->Utils().LogIt(_L("Finishing when count = %d should be %d"), 

					   count, iCount);

	iTest->EndTest(count != iCount);

	CActiveScheduler::Stop();

	}

void CQuitObject::DoCancel()

	{

	}

class CFTFilter : public CBase, public MHTTPFilter

	{

public:

	static CFTFilter* NewL(TInt aIndex, CHTTPFilterTest* aTest);

	virtual void MHFRunL(RHTTPTransaction aTransaction,

						 const THTTPEvent& aEvent);

	virtual TInt MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& aEvent);

	virtual void MHFSessionRunL(const THTTPSessionEvent& aEvent);

	virtual TInt MHFSessionRunError(TInt aError, const THTTPSessionEvent& aEvent);

	virtual void MHFLoad(RHTTPSession aSession, THTTPFilterHandle);

	virtual void MHFUnload(RHTTPSession aSession, THTTPFilterHandle);

	TInt iIndex;

	CHTTPFilterTest* iTest;

private:

	CFTFilter(TInt aIndex, CHTTPFilterTest* aTest) { iIndex = aIndex; iTest = aTest;}

	};

CFTFilter* CFTFilter::NewL(TInt aIndex, CHTTPFilterTest* aTest)

	{

	return new (ELeave) CFTFilter(aIndex, aTest);

	}

void CFTFilter::MHFLoad(RHTTPSession, THTTPFilterHandle)

	{

	}

void CFTFilter::MHFUnload(RHTTPSession, THTTPFilterHandle)

	{

	delete this;

	}

void CFTFilter::MHFRunL(RHTTPTransaction aTransaction,

						const THTTPEvent& /*aEvent*/)

	{

	iTest->Utils().LogIt(_L("Filter result %d is %d should be %d"), 

					   callCount, iIndex, callOrder[callCount]);

	iTest->EndTest(callOrder[callCount++]!=iIndex);

	iTest->Utils().LogIt(_L("filtering..."));

	if (callCount == 4)

		{

		aTransaction.SendEventL(THTTPEvent(33), THTTPEvent::EIncoming,

								THTTPFilterHandle(

									THTTPFilterHandle::ECurrentFilter));

		aTransaction.SendEventL(THTTPEvent(22), THTTPEvent::EIncoming,

								THTTPFilterHandle(

									THTTPFilterHandle::ECurrentFilter));

		aTransaction.SendEventL(THTTPEvent(22,KHTTPMatchAnyEventUid), THTTPEvent::EIncoming,

								THTTPFilterHandle(

									THTTPFilterHandle::ECurrentFilter));

		}

	}

void CFTFilter::MHFSessionRunL(const THTTPSessionEvent& /*aEvent*/)

	{

	}

TInt CFTFilter::MHFRunError(TInt aError, RHTTPTransaction /*aTransaction*/, const THTTPEvent& /*aEvent*/)

	{

	return aError;

	}

TInt CFTFilter::MHFSessionRunError(TInt aError, const THTTPSessionEvent& /*aEvent*/)

	{

	return aError;

	}

class CMyErrorFilter : public CBase, public MHTTPFilter

	{

public:

	static CMyErrorFilter* NewL(TInt aIndex, CHTTPFilterTest* aTest);

	virtual void MHFRunL(RHTTPTransaction aTransaction,

						 const THTTPEvent& aEvent);

	virtual TInt MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& aEvent);

	virtual void MHFSessionRunL(const THTTPSessionEvent& aEvent);

	virtual TInt MHFSessionRunError(TInt aError, const THTTPSessionEvent& aEvent);

	virtual void MHFLoad(RHTTPSession aSession, THTTPFilterHandle);

	virtual void MHFUnload(RHTTPSession aSession, THTTPFilterHandle);

	TInt iIndex;

	CHTTPFilterTest* iTest;

private:

	CMyErrorFilter(TInt aIndex, CHTTPFilterTest* aTest) { iIndex = aIndex; iTest = aTest;}

	};

CMyErrorFilter* CMyErrorFilter::NewL(TInt aIndex, CHTTPFilterTest* aTest)

	{

	return new (ELeave) CMyErrorFilter(aIndex, aTest);

	}

void CMyErrorFilter::MHFRunL(RHTTPTransaction aTransaction,

							 const THTTPEvent& aEvent)

	{

	iTest->Utils().LogIt(_L("Filter result %d is %d should be %d"), 

					   callCount, iIndex, callOrder[callCount]);

	iTest->EndTest(callOrder[callCount++]!=iIndex);

	iTest->Utils().LogIt(_L("filtering..."));

	if (aEvent == THTTPEvent::ECancel || aEvent == THTTPEvent::EClosed)

		return;

	if (callCount < 32)

		User::Leave(-1);

	if (callCount == 36)

		{

		aTransaction.Close();

		User::Leave(-1);

		}

	if (callCount == 45)

		User::Leave(-1);

	}

TInt CMyErrorFilter::MHFRunError(TInt /*aError*/, RHTTPTransaction aTransaction,

								 const THTTPEvent& /*aEvent*/)

	{

	if (callCount == 45)

		aTransaction.Close();

	return 0;

	}

void CMyErrorFilter::MHFUnload(RHTTPSession /*aSession*/, THTTPFilterHandle)

	{

	delete this;

	};

void CMyErrorFilter::MHFLoad(RHTTPSession, THTTPFilterHandle)

	{

	}

void CMyErrorFilter::MHFSessionRunL(const THTTPSessionEvent& /*aEvent*/)

	{

	}

TInt CMyErrorFilter::MHFSessionRunError(TInt aError, const THTTPSessionEvent& /*aEvent*/)

	{

	return aError;

	}

/*------------------------------------------------------------------------------*/

class CSessionEventFilter : public MHTTPFilter

	{	

public:

	static CSessionEventFilter* NewL(TInt aIndex, CHTTPFilterTest* aTest);

	virtual void MHFRunL(RHTTPTransaction aTransaction,

						 const THTTPEvent& aEvent);

	virtual TInt MHFRunError(TInt aError, RHTTPTransaction aTransaction, const THTTPEvent& aEvent);

	virtual void MHFSessionRunL(const THTTPSessionEvent& aEvent);

	virtual TInt MHFSessionRunError(TInt aError, const THTTPSessionEvent& aEvent);

	virtual void MHFLoad(RHTTPSession aSession, THTTPFilterHandle);

	virtual void MHFUnload(RHTTPSession aSession, THTTPFilterHandle);

	TInt iIndex;

	CHTTPFilterTest* iTest;

private:

	CSessionEventFilter(TInt aIndex, CHTTPFilterTest* aTest) { iIndex = aIndex; iTest = aTest;}

	};

CSessionEventFilter* CSessionEventFilter::NewL(TInt aIndex, CHTTPFilterTest* aTest)

	{

	return new (ELeave) CSessionEventFilter(aIndex, aTest);

	}

void CSessionEventFilter::MHFSessionRunL(const THTTPSessionEvent& /*aEvent*/)

	{

	iTest->Utils().LogIt(_L("Filter result %d is %d should be %d"), 

					   sessionCallCount, iIndex, sessionCallOrder[sessionCallCount]);

	iTest->EndTest(sessionCallOrder[sessionCallCount++]!=iIndex);

	iTest->Utils().LogIt(_L("filtering..."));

	}

TInt CSessionEventFilter::MHFSessionRunError(TInt /*aError*/, const THTTPSessionEvent& /*aEvent*/)

	{

	return 0;

	}

void CSessionEventFilter::MHFUnload(RHTTPSession /*aSession*/, THTTPFilterHandle)

	{

	delete this;

	};

void CSessionEventFilter::MHFLoad(RHTTPSession, THTTPFilterHandle)

	{

	}

TInt CSessionEventFilter::MHFRunError(TInt aError, RHTTPTransaction /*aTransaction*/,

								 const THTTPEvent& /*aEvent*/)

	{

	return aError;

	}

void CSessionEventFilter::MHFRunL(RHTTPTransaction /*aTransaction*/, const THTTPEvent& /*aEvent*/)

	{

	}

/*-------------------------------------------------------------------------------*/

CHTTPFilterTest* CHTTPFilterTest::NewL()

	{

	return new (ELeave) CHTTPFilterTest;

	}

void CHTTPFilterTest::DoRunSessionEventTestsL()

	{

	sessionCallCount = 0;

	RHTTPSession session;

	session.OpenL();

	CleanupClosePushL(session);

	TInt KEventUid1 = 1;

	TInt KEventUid2 = 2;

	CSessionEventFilter* sessionFilter1 = CSessionEventFilter::NewL(100001, this);

	CleanupStack::PushL(sessionFilter1);

	session.FilterCollection().AddFilterL(*sessionFilter1, THTTPEvent(THTTPEvent::EAnySessionEvent, KEventUid1),

											1, RStringF());

	CleanupStack::Pop(sessionFilter1);

	CSessionEventFilter* sessionFilter2 = CSessionEventFilter::NewL(100002, this);

	CleanupStack::PushL(sessionFilter2);

	session.FilterCollection().AddFilterL(*sessionFilter2, THTTPEvent(THTTPEvent::EAnySessionEvent, KEventUid2),

											2, RStringF());

	CleanupStack::Pop(sessionFilter2);

	CSessionEventFilter* sessionFilter3 = CSessionEventFilter::NewL(100003, this);

	CleanupStack::PushL(sessionFilter3);

	session.FilterCollection().AddFilterL(*sessionFilter3, THTTPEvent(THTTPEvent::EAnySessionEvent, KHTTPMatchAnyEventUid),

											3, RStringF());

	CleanupStack::Pop(sessionFilter3);

	CSessionEventFilter* sessionFilter4 = CSessionEventFilter::NewL(100004, this);

	CleanupStack::PushL(sessionFilter4);

	session.FilterCollection().AddFilterL(*sessionFilter4, THTTPEvent(100004, KHTTPMatchAnyEventUid),

											4, RStringF());

	CleanupStack::Pop(sessionFilter4);

	CSessionEventFilter* sessionFilter5 = CSessionEventFilter::NewL(100005, this);

	CleanupStack::PushL(sessionFilter5);

	session.FilterCollection().AddFilterL(*sessionFilter5, THTTPEvent(100005, KEventUid2),

											5, RStringF());

	CleanupStack::Pop(sessionFilter5);

	// Test outgoing session events

	session.SendSessionEventL(THTTPSessionEvent(100005, KEventUid2),

								THTTPSessionEvent::EOutgoing, THTTPFilterHandle(THTTPFilterHandle::EClient));

	session.SendSessionEventL(THTTPSessionEvent(100005, KEventUid1 ),

								THTTPSessionEvent::EOutgoing, THTTPFilterHandle(THTTPFilterHandle::EClient));

	session.SendSessionEventL(THTTPSessionEvent(100004, KEventUid1),

								THTTPSessionEvent::EOutgoing, THTTPFilterHandle(THTTPFilterHandle::EClient));

	session.SendSessionEventL(THTTPSessionEvent(100004, KEventUid2),

								THTTPSessionEvent::EOutgoing, THTTPFilterHandle(THTTPFilterHandle::EClient));

	// Test incoming session events

	session.SendSessionEventL(THTTPSessionEvent(100005, KEventUid2),

								THTTPSessionEvent::EIncoming, THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler));

	session.SendSessionEventL(THTTPSessionEvent(100005, KEventUid1 ),

								THTTPSessionEvent::EIncoming, THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler));

	session.SendSessionEventL(THTTPSessionEvent(100004, KEventUid1),

								THTTPSessionEvent::EIncoming, THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler));

	session.SendSessionEventL(THTTPSessionEvent(100004, KEventUid2),

								THTTPSessionEvent::EIncoming, THTTPFilterHandle(THTTPFilterHandle::EProtocolHandler));

	CQuitObject* quit = CQuitObject::NewL(22, this, ETrue);

	CleanupStack::PushL(quit);

	Utils().LogIt(_L("Creating transaction"));

	StartSchedulerL();

	CleanupStack::PopAndDestroy(2); //quit, session

	}

void CHTTPFilterTest::DoRunL()

	{

	iExpectedStatusCode = 0;

	iResult = 0;

	callCount = 0;

	TUriParser8 uri;

	uri.Parse(_L8("http://www.symbian.com"));

	// Do Session Event Tests first

	DoRunSessionEventTestsL();

	Utils().LogIt(_L("Creating session"));

	RHTTPSession a;

	CleanupClosePushL(a);

	a.OpenL();

	Utils().LogIt(_L("Adding filters"));

	CFTFilter* filter1 = CFTFilter::NewL(1, this);

	CleanupStack::PushL(filter1);

	a.FilterCollection().AddFilterL(*filter1, THTTPEvent(THTTPEvent::EAnyTransactionEvent),

				 RStringF(), KAnyStatusCode, 1, RStringF());

	CleanupStack::Pop(filter1);

	CFTFilter* filter2 = CFTFilter::NewL(2, this);

	CleanupStack::PushL(filter2);

	a.FilterCollection().AddFilterL(*filter2, THTTPEvent(THTTPEvent::EAnyTransactionEvent),

				 RStringF(), KAnyStatusCode, 4, RStringF());

	CleanupStack::Pop(filter2);

	CFTFilter* filter3 = CFTFilter::NewL(3, this);

	CleanupStack::PushL(filter3);

	a.FilterCollection().AddFilterL(*filter3, THTTPEvent(33),

				 RStringF(), KAnyStatusCode, 6, RStringF());

	CleanupStack::Pop(filter3);

	CFTFilter* filter4 = CFTFilter::NewL(4, this);

	CleanupStack::PushL(filter4);

	a.FilterCollection().AddFilterL(*filter4, THTTPEvent(THTTPEvent::EAnyTransactionEvent),

				 RStringF(), KAnyStatusCode, 9, RStringF());

	CleanupStack::Pop(filter4);

	CQuitObject* quit = CQuitObject::NewL(24, this);

	CleanupStack::PushL(quit);

	Utils().LogIt(_L("Creating transaction"));

	RHTTPTransaction b;

	b = a.OpenTransactionL(uri, *this, 

							 a.StringPool().OpenFStringL(KPost));

	Utils().LogIt(_L("starting events"));

	b.SendEventL(THTTPEvent(33), THTTPEvent::EOutgoing,

				 THTTPFilterHandle(THTTPFilterHandle::EClient));

	b.SendEventL(THTTPEvent(22), THTTPEvent::EOutgoing,

				 THTTPFilterHandle(THTTPFilterHandle::EClient));

	b.SendEventL(THTTPEvent(22,KHTTPMatchAnyEventUid), THTTPEvent::EOutgoing,

				 THTTPFilterHandle(THTTPFilterHandle::EClient));

	b.SendEventL(THTTPEvent(33), THTTPEvent::EOutgoing,

				 THTTPFilterHandle(THTTPFilterHandle::EClient));

	Utils().LogIt(_L("Starting filtering"));

	StartSchedulerL();

	Utils().LogIt(_L("Adding filter/event for error tests"));

	b.Close();

	CleanupStack::PopAndDestroy(quit);

	CMyErrorFilter* filter5 = CMyErrorFilter::NewL(6, this);

	CleanupStack::PushL(filter5);

	a.FilterCollection().AddFilterL(*filter5, THTTPEvent(THTTPEvent::EAnyTransactionEvent),

				 RStringF(), KAnyStatusCode, 11, RStringF());

	CleanupStack::Pop(filter5);

	quit = CQuitObject::NewL(35, this);

	CleanupStack::PushL(quit);

	b = a.OpenTransactionL(uri, *this, 

							 a.StringPool().OpenFStringL(KPost));

	b.SendEventL(THTTPEvent(33), THTTPEvent::EOutgoing,

				 THTTPFilterHandle(THTTPFilterHandle::EClient));

	Utils().LogIt(_L("filtering..."));

	StartSchedulerL();

	Utils().LogIt(_L("Testing session delete/leave interaction"));

	b.SendEventL(THTTPEvent(33), THTTPEvent::EOutgoing,

				 THTTPFilterHandle(THTTPFilterHandle::EClient));

	CleanupStack::PopAndDestroy(quit);

	quit = CQuitObject::NewL(44, this);

	CleanupStack::PushL(quit);

	StartSchedulerL();

	Utils().LogIt(_L("Deleting from a RunError"));

	RHTTPTransaction c;

	c = a.OpenTransactionL(uri, *this, 

						   a.StringPool().OpenFStringL(KPost));

	c.SendEventL(THTTPEvent(33), THTTPEvent::EOutgoing,

				 THTTPFilterHandle(THTTPFilterHandle::EClient));

	CleanupStack::PopAndDestroy(quit);

	quit = CQuitObject::NewL(53, this);

	CleanupStack::PushL(quit);

	StartSchedulerL();

	Utils().LogIt(_L("Testing status code matching with no response"));

	CFTFilter* filter6 = CFTFilter::NewL(7, this);

	CleanupStack::PushL(filter6);

	a.FilterCollection().AddFilterL(*filter6, THTTPEvent(THTTPEvent::EAnyTransactionEvent),

				 RStringF(), 200, 10, RStringF());

	CleanupStack::Pop(filter6);

	RHTTPTransaction d;

	d = a.OpenTransactionL(uri, *this, 

						   a.StringPool().OpenFStringL(KPost));

	d.SendEventL(THTTPEvent(33), THTTPEvent::EOutgoing,

				 THTTPFilterHandle(THTTPFilterHandle::EClient));

	CleanupStack::PopAndDestroy(quit);

	quit = CQuitObject::NewL(58, this);

	CleanupStack::PushL(quit);

	StartSchedulerL();

	Utils().LogIt(_L("Testing status code matching - codes do match"));

	d.Response().SetStatusCode(200);

	d.SendEventL(THTTPEvent(33), THTTPEvent::EOutgoing,

				 THTTPFilterHandle(THTTPFilterHandle::EClient));

	CleanupStack::PopAndDestroy(quit);

	quit = CQuitObject::NewL(64, this);

	CleanupStack::PushL(quit);