diff -r 000000000000 -r b16258d2340f applayerprotocols/httpservice/test/httpservicetest/ctestserverstreammanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerprotocols/httpservice/test/httpservicetest/ctestserverstreammanager.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,268 @@
+// Copyright (c) 2003-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 "ctestserverstreammanager.h"
+#include <minputstream.h>
+#include <moutputstream.h>
+#include "httptestutils.h"
+#include "chttpclienttestparams.h"
+
+const TUint KCarriageReturn = '\r';
+const TUint KLineFeed       = '\n';
+const TUint KSpace          = ' ';
+
+CLocalTestServerStreamManager* CLocalTestServerStreamManager::NewL(CHTTPTestUtils& aTestUtils, MInputStream* aInStream, MOutputStream* aOutStream, CHttpClientTestParamArray& aTestParamArray)
+	{
+	CLocalTestServerStreamManager* self = new(ELeave) CLocalTestServerStreamManager(aTestUtils, aInStream, aOutStream, aTestParamArray);
+	CleanupStack::PushL(self);
+	
+	CleanupStack::Pop();	
+	return self;
+	} 
+	
+CLocalTestServerStreamManager::~CLocalTestServerStreamManager()
+	{
+    if(iInputStream != NULL)
+        {
+        iInputStream->Close();
+        }
+    if(iOutputStream != NULL)
+        {
+        iOutputStream->Close();
+        }	
+	delete iRequestStream;	
+	delete iResponseStream;
+	}
+	
+CLocalTestServerStreamManager::CLocalTestServerStreamManager(CHTTPTestUtils& aTestUtils, MInputStream* aInStream, MOutputStream* aOutStream, CHttpClientTestParamArray& aTestParamArray)
+: iTestUtils(aTestUtils),
+iInputStream(aInStream),
+iOutputStream(aOutStream),
+iTestParamArray(aTestParamArray)
+	{
+    iInputStream->Bind(*this);
+    iOutputStream->Bind(*this);	
+	}
+	
+// From MInputStreamObserver
+void CLocalTestServerStreamManager::ReceivedDataIndL(const TDesC8& aBuffer)
+	{
+    _LIT(KTxtConnection, "Stream Manager - Data received.");
+    iTestUtils.LogIt(KTxtConnection());
+	
+	if(iRequestStream == NULL)
+	    {
+	    iRequestStream = aBuffer.AllocL();
+	    }
+	else
+	    {
+	    // Check to see if the buffer needs to grow
+        TInt maxLength  = iRequestStream->Des().MaxLength();
+        TInt reqdLength = iRequestStream->Length() + aBuffer.Length();
+	    if (reqdLength > maxLength)
+	        {
+	        HBufC8* largerBuffer = iRequestStream->ReAllocL(maxLength + aBuffer.Length());
+
+	        // Switch buffers. The old one was removed by ReAlloc.
+	        iRequestStream = largerBuffer;
+	        }
+
+	    // Can now append confidently
+	    iRequestStream->Des().Append(aBuffer);
+	    }
+	   iInputStream->ReceivedDataRes();	    
+	ProcessRequestStreamL();
+	}
+	
+void CLocalTestServerStreamManager::SecureServerCnf()
+	{
+	}
+	
+void CLocalTestServerStreamManager::InputStreamCloseInd(TInt /* aError */)
+	{
+	iInputStream = NULL;		
+	}
+	
+void CLocalTestServerStreamManager::MInputStreamObserver_Reserved()
+	{
+	}
+	
+MHttpResponse* CLocalTestServerStreamManager::CurrentResponse()
+	{
+	return NULL;		
+	}
+	
+void CLocalTestServerStreamManager::OnReceiveTimeOut()	
+	{
+	}
+	
+// From MOutputStreamObserver
+void CLocalTestServerStreamManager::SendDataCnfL()
+	{
+   _LIT(KTxtSendData, "Stream Manager - Sending data.");
+    iTestUtils.LogIt(KTxtSendData());
+	
+	if(iSendingBodyData)
+	    {
+	    SendDataL ();
+	    }
+	else
+	    {
+	    if(iCurrentTestParam->RequestBody().Length() > 0)
+	        {
+	        iInputStream->ShutdownReq();
+	        return;
+	        }
+	    if(iRequestStream == NULL)
+	        return;
+	    // Remove the current request from the request stream.
+	    TPtr8 ptrStream = iRequestStream->Des();
+	    TInt lenToRemove = iCurrentTestParam->RawRequest().Length();
+	    TPtrC8 dataWindow;
+	    if(lenToRemove < iRequestStream->Length())
+	        {
+	        dataWindow.Set(iRequestStream->Mid(lenToRemove));
+	        }
+	    TPtrC8 dataToCompare(iRequestStream->Ptr(), lenToRemove);
+	    if(!iCurrentTestParam->IsFileSending() && iCurrentTestParam->RawRequest().CompareF(dataToCompare) != 0)
+	        {
+	        User::Leave(KErrCorrupt);
+	        }
+	    delete iRequestStream;
+        iRequestStream = NULL;
+        iRequestStream = dataWindow.AllocL();
+	        
+	    if(iRequestStream->Length() > 0)
+	        {
+	        iCurrentTestParam = NULL;
+	        iSendingBodyData = EFalse;
+	        ProcessRequestStreamL();
+	        }
+	    }
+	}
+	
+void CLocalTestServerStreamManager::SecureClientCnf()
+	{
+	}
+	
+void CLocalTestServerStreamManager::OutputStreamCloseInd(TInt /* aError */)
+	{
+	iOutputStream = NULL;		
+	}
+	
+void CLocalTestServerStreamManager::MOutputStreamObserver_Reserved()
+	{
+	}
+
+void CLocalTestServerStreamManager::OnSendTimeOut()
+    {
+    }
+
+TInt CLocalTestServerStreamManager::SendTimeOutVal()
+	{
+	return 0;
+	}
+
+void CLocalTestServerStreamManager::SendDataL()
+    {
+    delete iResponseStream;
+    iResponseStream = NULL;
+    if(!iSendingBodyData)
+        {
+        iResponseStream = iCurrentTestParam->RawResponse().AllocL();
+        iSendingBodyData = ETrue;
+        }
+    else
+        {
+        delete iResponseStream;
+        iResponseStream = NULL;
+        _LIT8(KPostMethod, "POST");
+        if(iCurrentTestParam->RequestBody().Length() == 0 && iCurrentTestParam->Method().CompareF(KPostMethod()) == 0)
+            {
+            iCurrentTestParam->SinkFile().Close();
+            iInputStream->ShutdownReq();
+            return;
+            }
+        if(iCurrentTestParam->IsFileSending())
+            {
+            iResponseStream = iCurrentTestParam->ReadFromFile().AllocL();
+            iSendingBodyData = iCurrentTestParam->IsPendingRead();
+            }
+        else
+            {
+            if(iCurrentTestParam->ResponseBody().Length() > 0)
+                {
+                iResponseStream = iCurrentTestParam->ResponseBody().AllocL();
+                }
+            iSendingBodyData = EFalse;
+            }
+        
+        
+        }
+    if(iResponseStream)
+        iOutputStream->SendDataReqL(*iResponseStream);
+    }
+
+void CLocalTestServerStreamManager::ProcessRequestStreamL()
+    {
+    if(iSendingBodyData)
+        return;
+    _LIT8(KResponseTimeoutURI, "GET /index17.html HTTP/1.1\r\nHost: 127.0.0.1\r\nUser-Agent: HTTP Client API Test\r\n\r\n");
+    // First see whether we received a request. by checking whether the startline
+    // exists.
+    _LIT8(KLineEnd, "\r\n");
+    TPtrC8 ptrStream(*iRequestStream);
+    TInt pos = ptrStream.FindF(KLineEnd);
+    if(pos != KErrNotFound)
+        {
+        // Ok now we have a URI that matches. Now check if the URI is a timeout URI.
+        if(ptrStream.CompareF(KResponseTimeoutURI) != 0)
+            {
+            _LIT8(KPostMethod, "POST");
+            TPtrC8 startLine = ptrStream.Left(pos);
+            iCurrentTestParam = iTestParamArray.MatchingParam(startLine); 
+            if(iCurrentTestParam && !iCurrentTestParam->NeedDisconnection() &&  iCurrentTestParam->Method().CompareF(KPostMethod) != 0
+                    && (iCurrentTestParam->ResponseBody().Length() > 0 || iCurrentTestParam->IsFileSending()))
+                {            
+                SendDataL();
+                }
+            else if(iCurrentTestParam && iCurrentTestParam->NeedDisconnection())
+                {
+                iInputStream->ShutdownReq();
+                } 
+            else if(iCurrentTestParam && (ptrStream.Length() == iCurrentTestParam->RawRequest().Length()) && !iCurrentTestParam->IsFileSending())
+                {
+                SendDataL();
+                }
+            
+            if(iCurrentTestParam && iCurrentTestParam->Method().CompareF(KPostMethod) == 0 && iCurrentTestParam->IsFileSending() && iCurrentTestParam->RequestBody().Length() == 0)
+                {
+                iWritingUploadFile = ETrue;
+                }
+            }
+        }
+    if(iWritingUploadFile)
+        {
+        iCurrentTestParam->WriteToFile(ptrStream);
+        delete iRequestStream;
+        iRequestStream = NULL;
+        TInt reqLen =  iCurrentTestParam->RawRequest().Length();
+        TInt totalLen = (reqLen + iCurrentTestParam->SendingFileSize());
+        if(iCurrentTestParam->ReceivingFileSize() == totalLen)
+            {
+            SendDataL();
+            }
+        }
+    }