--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerprotocols/httptransportfw/Test/TestScriptTest/CPipeliningTestParams.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,803 @@
+// 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 "CPipeliningTestParams.h"
+#include "httptestutils.h"
+#include "CPipeliningTestCase.h"
+
+
+const TUint KDoubleQuote ('"');
+_LIT(KScriptLF, 	"\\n");
+_LIT(KReplaceLF,	"\n");
+_LIT8(KScriptLF8, 	"\\n");
+_LIT8(KReplaceLF8,	"\n");
+
+_LIT(KScriptCR, 	"\\r");
+_LIT(KReplaceCR,	"\r");
+_LIT8(KScriptCR8, 	"\\r");
+_LIT8(KReplaceCR8,	"\r");
+
+
+
+
+TInt err(0);
+//Helper function to convert TPtr to TInt
+static TInt Ptr2Int(const TDesC& aPtr)
+	{
+	TInt aInt;
+	TLex aLex(aPtr);
+	aLex.Val(aInt);
+	return aInt;
+	}
+
+void CheckSetHeaderValueL(const TDesC& aTransInfoBuf, const TDesC& aHeader2Check, TransInfo& aTransInfo, const TInt aLocationInHeaderArr)
+	{
+	TChar commaChar (',');
+	TChar colonChar (':');
+	TInt locationOfDes = aTransInfoBuf.Match(aHeader2Check);
+	
+	if (locationOfDes != KErrNotFound)//the header has been found in the input string
+		{
+	 	TPtrC subString = aTransInfoBuf.Mid(locationOfDes);
+	  	TInt commaDelimterPos = subString.Locate(commaChar);
+	  	TPtrC headerFieldValuePairString = subString.Mid(locationOfDes, (commaDelimterPos != KErrNotFound ? commaDelimterPos:subString.Length()));		
+	 	TInt colonDelimterPos = headerFieldValuePairString.Locate(colonChar);
+	 	TPtrC headerVal = headerFieldValuePairString.Mid(colonDelimterPos+1 );
+	 	HBufC *headerValueBuf = HBufC::NewLC(headerVal.Size());
+	 	(headerValueBuf->Des()).Copy(headerVal);
+	 	User::LeaveIfError(aTransInfo.TransHeaderInfoPtrArr.Append(headerValueBuf));
+	 	User::LeaveIfError(aTransInfo.TransHeaderTypeArr.Insert(((aTransInfo.TransHeaderInfoPtrArr.Count()) - 1),aLocationInHeaderArr));
+	 	CleanupStack::Pop(headerValueBuf);
+	 	}
+	 else//header is not present in the string
+	 	{
+	 	aTransInfo.TransHeaderTypeArr.Insert( ( -1 ), aLocationInHeaderArr );
+	 	}
+	}
+	
+
+CPipeliningTestParams* CPipeliningTestParams::NewL(CHTTPTestUtils& aTestUtils)
+	{
+	CPipeliningTestParams* self = new (ELeave) CPipeliningTestParams(aTestUtils);
+	return self;
+	}
+
+CPipeliningTestParams::CPipeliningTestParams(CHTTPTestUtils& aTestUtils)
+:iTestUtils(aTestUtils)
+	{
+	//Only Initializing integers, for the strings we need to know the size.
+	iBufferSize = -1;
+	iConnectionCount = -1;
+	iTotalTransactionCount = -1;
+	}
+
+CPipeliningTestParams::~CPipeliningTestParams()
+	{
+	delete iTestCaseNameBuf;
+	delete iReqMethod;
+	TInt count;
+	
+	count = iUriBufArr.Count();
+	for (TInt ii=0; ii < count ; ++ii )
+		{
+		delete iUriBufArr[ii];
+		}	
+	iUriBufArr.Close();
+	
+	count = iRawRequestBufArr.Count();
+	for (TInt ii=0; ii < count ; ++ii )
+		{
+		delete iRawRequestBufArr[ii];
+		}
+	iRawRequestBufArr.Close();
+	
+	count = iRawResponseBufArr.Count();
+	for (TInt ii=0; ii < count; ++ii )
+		{
+		delete iRawResponseBufArr[ii];	
+		}
+	iRawResponseBufArr.Close();
+	
+	
+	count = iConnReq2DArr.Count();
+	for (TInt ii=0; ii < count; ++ii )
+		{
+		iConnReq2DArr[ii].Close();
+		}
+	iConnReq2DArr.Close();
+	
+	count = iConnResp2DArr.Count();
+	for (TInt ii=0; ii < count; ++ii )
+		{
+		iConnResp2DArr[ii].Close();	
+		}
+	iConnResp2DArr.Close();
+	
+	TInt temp = iTransTypesInfoPtrArr.Count();
+	for ( TInt ii=0; ii < temp; ++ii)
+		{
+		iTransTypesInfoPtrArr[ii]->TransHeaderTypeArr.Close();
+		iTransTypesInfoPtrArr[ii]->TransHeaderInfoPtrArr.ResetAndDestroy();
+		delete iTransTypesInfoPtrArr[ii];
+		}
+	iTransTypesInfoPtrArr.Close();
+	
+	count = iHeader2ProcessArr.Count();
+
+	for (TInt ii=0; ii < count; ++ii )
+		{
+		delete iHeader2ProcessArr[ii];
+		}
+	
+	count = iHdrVal2DArr.Count();
+	for (TInt ii=0; ii < count; ++ii )
+		{
+		TInt hdrValCount = iHdrVal2DArr[ii].Count();
+		for (TInt jj=0; jj < hdrValCount; ++jj)
+			{
+			delete iHdrVal2DArr[ii][jj];
+			}
+		iHdrVal2DArr[ii].Close();
+		}			
+	iHdrVal2DArr.Close();
+	iHeader2ProcessArr.Close();
+	iTransArr.Close();
+	}
+
+
+//RunTest
+void CPipeliningTestParams::SetRunTest(const TDesC& aRunTest)
+	{
+	iRunTest = Ptr2Int(aRunTest);
+	}
+
+TBool	CPipeliningTestParams::RunTest() const
+	{
+	return iRunTest;
+	}
+
+//Batching Enabled
+void CPipeliningTestParams::EnableBatching(const TDesC& aIsBatchingEnabled)
+	{
+	iBatchingEnabled = Ptr2Int(aIsBatchingEnabled);
+	}
+
+TBool CPipeliningTestParams::BatchingEnabled() const
+	{
+	return iBatchingEnabled;
+	}
+
+//Pipelining Enabled
+void CPipeliningTestParams::EnablePipelining(const TDesC& aIsPipeliningEnabled)
+	{
+	iPipeliningEnabled = Ptr2Int(aIsPipeliningEnabled);	
+	}
+	
+TBool	CPipeliningTestParams::PipeliningEnabled() const
+	{
+	return iPipeliningEnabled;
+	}
+	
+
+//Buffer Size
+void CPipeliningTestParams::SetBufferSize(const TDesC& aBufferSize)
+	{
+	iBufferSize = Ptr2Int(aBufferSize);
+	}
+
+TInt	CPipeliningTestParams::BufferSize() const
+	{
+	return iBufferSize;
+	}
+
+
+
+//Error	
+void CPipeliningTestParams::SetErrorL(const TDesC& aError)
+	{
+	HBufC* iErrorBuf = HBufC::NewLC(aError.Size());
+	(iErrorBuf->Des()).Copy(aError);
+	RemoveQuotes(iErrorBuf)	;
+	ParseReplaceCRLF(iErrorBuf) ;
+	
+	if(iErrorBuf->Des().Compare(_L("KErrDisconnected")) == 0)
+		{
+		iError = KErrDisconnected;
+		}
+		
+	else if (iErrorBuf->Des().Compare(_L("KErrCancel")) == 0)
+		{
+		iError = KErrCancel;
+		}
+	else
+		{
+		iError = KErrNone;				
+		}	
+	
+	CleanupStack::PopAndDestroy(iErrorBuf);
+	}
+
+TInt CPipeliningTestParams::Error() const
+	{
+	return iError;
+	}
+
+//Connection Count	
+void CPipeliningTestParams::SetConnectionCount(const TDesC& aConnectionCount)
+	{
+	iConnectionCount = Ptr2Int(aConnectionCount);
+	}
+
+TInt CPipeliningTestParams::ConnectionCount() const
+	{
+	return iConnectionCount;
+	}
+	
+//Request Method
+void CPipeliningTestParams::SetReqMethodL(const TDesC& aReqMethod)	
+	{
+	iReqMethod = HBufC::NewL(aReqMethod.Size());
+	(iReqMethod->Des()).Copy(aReqMethod);
+	RemoveQuotes(iReqMethod);
+	}
+
+TDesC16& CPipeliningTestParams::ReqMethod()
+	{
+	return (*(iReqMethod));
+	}
+
+//Transaction Count
+void CPipeliningTestParams::SetTotalTransactionCount(const TDesC& aTotalTransCount)
+	{
+	iTotalTransactionCount = Ptr2Int(aTotalTransCount);
+	}
+
+void CPipeliningTestParams::DecreaseTotalTransactionCount() const
+	{
+		--iTotalTransactionCount;
+	}
+
+TInt CPipeliningTestParams::TotalTransactionCount() const
+	{
+	return iTotalTransactionCount;
+	}
+
+//Transaction Count
+TInt CPipeliningTestParams::TransactionCount(TInt aConnIndex) const
+	{
+	
+	TInt outerSize = iConnReq2DArr.Count();
+	
+	for (TInt x=0; x < outerSize; ++x )
+	{
+	TInt innerSize = iConnReq2DArr[x].Count();
+	}
+	
+	__ASSERT_ALWAYS( ((aConnIndex < iConnReq2DArr.Count()) && (aConnIndex >= 0)), User::Invariant());
+	
+	return iConnReq2DArr[aConnIndex].Count();
+	}
+	
+
+//Test Case Name
+void CPipeliningTestParams::SetTestCaseNameL(const TDesC& aTestCaseName ) 
+	{
+	iTestCaseNameBuf = HBufC::NewL(aTestCaseName.Size());
+	(iTestCaseNameBuf->Des()).Copy(aTestCaseName);
+	RemoveQuotes(iTestCaseNameBuf);
+	}
+
+TDesC& CPipeliningTestParams::TestCaseName() const
+	{
+	return (*(iTestCaseNameBuf));
+	}
+
+
+//Uri
+void CPipeliningTestParams::SetUriL(TInt aUriIndex, const TDesC& aUri)
+	{
+	if (aUriIndex == 0)
+		{
+		iUriBufArr.Reset();
+		}
+
+	TInt uriSize = aUri.Size();
+
+	HBufC8* tmpUri;
+	tmpUri = HBufC8::NewLC(((uriSize%2) == 0)? (uriSize/2):((uriSize/2)+1));
+	User::LeaveIfError(iUriBufArr.Append(tmpUri));
+	((iUriBufArr[aUriIndex])->Des()).Copy(aUri);
+
+	RemoveQuotes(iUriBufArr[aUriIndex]);
+	CleanupStack::Pop(tmpUri);
+	}
+
+
+
+TInt CPipeliningTestParams::UriCount() const
+	{
+	return iUriBufArr.Count();
+	}
+
+
+
+
+TDesC8&	CPipeliningTestParams::UriL(TInt aUriIndex) const
+	{
+	__ASSERT_ALWAYS( ((aUriIndex < iUriBufArr.Count()) && (aUriIndex >= 0)), User::Leave(KErrArgument));
+	
+	return (*(iUriBufArr[aUriIndex]));
+	}
+
+
+
+
+//Raw Request
+//store the raw request strings
+void CPipeliningTestParams::SetRawRequestL(TInt aTransIndex, const TDesC& aRawRequest)
+	{
+	TInt rawRequestSize = aRawRequest.Size();
+	HBufC8* tmpRequest = HBufC8::NewLC(((rawRequestSize%2) == 0)? (rawRequestSize/2):((rawRequestSize/2)+1));
+	User::LeaveIfError(iRawRequestBufArr.Append(tmpRequest));
+	((iRawRequestBufArr[aTransIndex])->Des()).Copy(aRawRequest);
+
+	RemoveQuotes(iRawRequestBufArr[aTransIndex])	;
+	ParseReplaceCRLF(iRawRequestBufArr[aTransIndex]) ;
+	CleanupStack::Pop(tmpRequest);
+	}
+	
+//return the raw request based on the request array (rawrequest[(iConnRequest2DArr[connIndex][transIndex])]
+TDesC8&	CPipeliningTestParams::RawRequest(TInt aConnIndex, TInt aTransIndex) const
+	{
+	__ASSERT_ALWAYS( ((aConnIndex < iConnReq2DArr.Count()) && (aConnIndex >= 0)), User::Invariant());
+	__ASSERT_ALWAYS( ((aTransIndex < iConnReq2DArr[aConnIndex].Count()) && (aTransIndex >= 0)), User::Invariant());
+
+	TInt returnIndex = iConnReq2DArr[aConnIndex][aTransIndex];
+	return (*( iRawRequestBufArr[ returnIndex - 1 ] ) );
+	}
+
+TDesC8&	CPipeliningTestParams::RawRequest( TInt aRawRequestBufArrIndex ) const
+	{
+	__ASSERT_ALWAYS( ((aRawRequestBufArrIndex < iRawRequestBufArr.Count()) && (aRawRequestBufArrIndex >= 0)), User::Invariant());
+
+	return (*(iRawRequestBufArr[aRawRequestBufArrIndex]));
+	}
+	
+//Raw Response
+void CPipeliningTestParams::SetRawResponseL(TInt aTransIndex, const TDesC& aRawResponse)
+	{
+	TInt rawResponseSize = aRawResponse.Size();
+	HBufC8* tmpResponse = HBufC8::NewLC(((rawResponseSize%2) == 0)? (rawResponseSize/2):((rawResponseSize/2)+1));
+	User::LeaveIfError(iRawResponseBufArr.Append(tmpResponse));
+	((iRawResponseBufArr[aTransIndex])->Des()).Copy(aRawResponse);
+
+	RemoveQuotes(iRawResponseBufArr[aTransIndex])	;
+	ParseReplaceCRLF(iRawResponseBufArr[aTransIndex]) ;
+	CleanupStack::Pop(tmpResponse);
+	}
+
+
+
+
+
+TDesC8&	CPipeliningTestParams::RawResponse(TInt aConnIndex, TInt aTransIndex) const
+	{
+	__ASSERT_ALWAYS( ((aConnIndex < iConnResp2DArr.Count()) && (aConnIndex >= 0)), User::Invariant());
+	__ASSERT_ALWAYS( ((aTransIndex < iConnResp2DArr[aConnIndex].Count()) && (aTransIndex >= 0)), User::Invariant());
+		
+	TInt returnIndex = iConnResp2DArr[aConnIndex][aTransIndex];
+	return (*(iRawResponseBufArr[ returnIndex - 1 ]));
+	}
+
+
+
+
+
+TDesC8&	CPipeliningTestParams::RawResponse( TInt aRawResponseBufArrIndex ) const
+	{
+	__ASSERT_ALWAYS( ((aRawResponseBufArrIndex < iRawResponseBufArr.Count()) && (aRawResponseBufArrIndex >= 0)), User::Invariant());
+	
+	return (*(iRawResponseBufArr[aRawResponseBufArrIndex]));
+	}
+
+
+
+
+//Returns a TransInfo instance
+TransInfo& CPipeliningTestParams::TransactionType(TInt atransTypeNum) const
+	{
+	TInt transTypeIndex = -1;
+	for (TInt x=0; x < iTransTypesInfoPtrArr.Count(); ++x)
+		{
+		if (iTransTypesInfoPtrArr[x]->TransType == atransTypeNum)
+			{
+			transTypeIndex = x;
+			}
+		}
+	__ASSERT_ALWAYS((transTypeIndex >= 0),User::Invariant());
+	return (*(iTransTypesInfoPtrArr[transTypeIndex]));
+	}
+
+
+
+
+TInt CPipeliningTestParams::SetTransactionTypeL(TInt aTransTypeNumber, TDesC& aTransInfoDesc)
+	{
+	HBufC* transInfoBuf = HBufC::NewL(aTransInfoDesc.Size());
+	CleanupStack::PushL( transInfoBuf );
+	(transInfoBuf->Des()).Copy(aTransInfoDesc);
+
+	RemoveQuotes(transInfoBuf)	;
+	ParseReplaceCRLF(transInfoBuf) ;
+
+	//Create an instance of transInfo structure on heap
+	TransInfo* transInfo = new (ELeave) TransInfo;
+	iTransTypesInfoPtrArr.Append(transInfo);
+	
+	//testing
+	transInfo->TransHeaderTypeArr.Insert( -1 , 0 );
+	
+	//Set the transaction type number
+	transInfo->TransType = aTransTypeNumber;
+	
+	//Parse the string transInfoBuf at comma's
+	//Get a bunch of substrings delimited by comma	
+
+	CheckSetHeaderValueL(*transInfoBuf, _L("*HTTP*"), *transInfo, EHttpHeader);
+	CheckSetHeaderValueL(*transInfoBuf, _L("*Connection*"), *transInfo, EConnectionHeader);
+	CheckSetHeaderValueL(*transInfoBuf, _L("*Batching*"), *transInfo, EBatchingHeader);
+	CheckSetHeaderValueL(*transInfoBuf, _L("*Transaction*"), *transInfo, ETransactionHeader);
+	
+	CleanupStack::PopAndDestroy( transInfoBuf );
+	
+	return 0;												
+	}
+
+
+
+
+
+TBool CPipeliningTestParams::ProcessHeader() const
+	{
+	return iProcessHdr;
+	}
+
+
+void CPipeliningTestParams::SetHeaderToProcessL(const TInt aHdrIdx, const TDesC& aHeaderName ) 
+	{	
+	__ASSERT_ALWAYS((((aHdrIdx -1) >= 0) && ((aHdrIdx -1) == iHeader2ProcessArr.Count()  )), User::Invariant());
+	
+	TInt aHeaderNameSize = aHeaderName.Size();
+	HBufC8* tmpHdr = HBufC8::NewLC(((aHeaderNameSize%2) == 0)? (aHeaderNameSize/2):((aHeaderNameSize/2)+1));
+	User::LeaveIfError(iHeader2ProcessArr.Append(tmpHdr));
+	((iHeader2ProcessArr[aHdrIdx-1])->Des()).Copy(aHeaderName);
+
+	RemoveQuotes(iHeader2ProcessArr[aHdrIdx - 1])	;
+	ParseReplaceCRLF(iHeader2ProcessArr[aHdrIdx - 1]) ;
+	
+	iProcessHdr = ETrue;
+	CleanupStack::Pop(tmpHdr);
+	}
+
+
+// Number of headers for this transaction
+TInt CPipeliningTestParams::NumHdrs() const
+	{
+	return iHeader2ProcessArr.Count();
+	}
+
+
+TDesC8& CPipeliningTestParams::HeaderToProcess(TInt aHdrIdx) const
+	{
+	__ASSERT_ALWAYS( (((aHdrIdx) < iHeader2ProcessArr.Count()) && ((aHdrIdx) >= 0)), User::Invariant());
+	
+	return (*(iHeader2ProcessArr[aHdrIdx]));
+	}
+
+
+
+
+//Value expected for the header
+//1. Number of header values for this header
+TInt CPipeliningTestParams::NumberOfHeaderVals(const TInt aHdrIdx) const
+	{
+	__ASSERT_ALWAYS( ((aHdrIdx < iHeader2ProcessArr.Count()) && (aHdrIdx >= 0)), User::Invariant());
+	
+	return iHdrVal2DArr[aHdrIdx].Count();
+	}
+
+TDesC8& CPipeliningTestParams::HeaderVal(const TInt aHdrCtr, const TInt aHdrValCtr ) const
+	{
+	__ASSERT_ALWAYS( ((aHdrCtr-1 < iHeader2ProcessArr.Count()) && (aHdrCtr-1 >= 0)), User::Invariant());		
+	__ASSERT_ALWAYS( ((aHdrValCtr-1 < iHdrVal2DArr[aHdrCtr-1].Count()) && (aHdrValCtr-1 >= 0)), User::Invariant());
+	
+	return (*(iHdrVal2DArr[aHdrCtr - 1][aHdrValCtr - 1]));
+	
+	}
+
+void CPipeliningTestParams::SetHdrValL(const TInt aHdrIdx, const TInt aHdrValIdx, const TDesC& aHdrVal)
+	{
+	__ASSERT_ALWAYS( (((aHdrIdx-1) < iHeader2ProcessArr.Count()) && ((aHdrIdx-1) >= 0)), User::Invariant());		
+
+
+	TInt aHdrValSize = aHdrVal.Size();
+	RArray < HBufC8 * > y ;
+
+	
+	if ( iHdrVal2DArr.Count() <= (aHdrIdx-1) )
+		{
+		User::LeaveIfError(iHdrVal2DArr.Append(y));
+		}
+	else
+		{
+		y = iHdrVal2DArr[aHdrIdx-1];
+		}
+		
+	HBufC8* tmpHdr = HBufC8::NewLC(((aHdrValSize%2) == 0)? (aHdrValSize/2):((aHdrValSize/2)+1));
+	User::LeaveIfError(y.Append(tmpHdr));
+	y[aHdrValIdx-1]->Des().Copy(aHdrVal);		
+	
+	iHdrVal2DArr.Remove ( aHdrIdx - 1 );
+	iHdrVal2DArr.Insert ( y, aHdrIdx - 1 );
+
+	HBufC8* xyz = y[aHdrValIdx-1];
+	HBufC8* xyz1 = iHdrVal2DArr[aHdrIdx-1][aHdrValIdx-1];
+	
+	TPtr8 ptr = xyz->Des();
+	TPtr8 ptr1 = xyz1->Des();
+
+	RemoveQuotes(iHdrVal2DArr[aHdrIdx - 1][aHdrValIdx - 1])	;
+	ParseReplaceCRLF(iHdrVal2DArr[aHdrIdx - 1][aHdrValIdx - 1]) ;
+	
+	CleanupStack::Pop(tmpHdr);
+	}
+//Parse Replace to replace double quotes
+void CPipeliningTestParams::RemoveQuotes(HBufC16* aHBufPtr) 
+	{
+	if (((*aHBufPtr)[0]) == KDoubleQuote)
+		{
+		(aHBufPtr->Des()).Delete(0,1);
+		}
+		
+	TInt lastChar = ((aHBufPtr->Des()).Length());
+	--lastChar;
+	
+	if ((*aHBufPtr)[lastChar] == KDoubleQuote)
+		{
+		(aHBufPtr->Des()).Delete(lastChar,1);
+		}
+		
+	}
+
+
+
+
+void CPipeliningTestParams::RemoveQuotes(HBufC8* aHBufPtr) 
+	{
+	if ((( *aHBufPtr )[0]) == KDoubleQuote)
+		{
+		( aHBufPtr->Des() ).Delete(0,1);
+		}	
+		
+	TInt lastChar = ((aHBufPtr->Des()).Length());
+	--lastChar;
+	
+	if (( *aHBufPtr )[lastChar] == KDoubleQuote)
+		{
+		( aHBufPtr->Des() ).Delete(lastChar,1);
+		}
+		
+	}
+
+
+
+
+//Parse Replace \n & \r
+void CPipeliningTestParams::ParseReplaceCRLF(HBufC8* aHBufPtr)
+	{
+	TInt crPos = 0;
+	TInt lfPos = 0;
+	do
+		{
+
+		crPos = ((aHBufPtr->Des()).Find(KScriptCR8()));
+		if (crPos != KErrNotFound)
+			{
+			(aHBufPtr->Des()).Replace(crPos,2, KReplaceCR8());
+			}
+			
+		}
+	while (crPos != KErrNotFound );
+
+
+	do
+		{
+
+		lfPos = ((aHBufPtr->Des()).Find(KScriptLF8()));
+		if (lfPos != KErrNotFound)
+			{
+			(aHBufPtr->Des()).Replace(lfPos,2, KReplaceLF8());
+			}
+			
+		}
+	while (lfPos != KErrNotFound );
+	
+	}
+
+
+
+
+void CPipeliningTestParams::ParseReplaceCRLF(HBufC16* aHBufPtr)
+	{
+	TInt crPos = 0;
+	TInt lfPos = 0;
+	do
+		{
+
+		crPos = ((aHBufPtr->Des()).Find(KScriptCR()));
+		if (crPos != KErrNotFound)
+			{
+			(aHBufPtr->Des()).Replace(crPos,2, KReplaceCR());
+			}
+			
+		}
+	while (crPos != KErrNotFound );
+
+
+	do
+		{
+
+		lfPos = ((aHBufPtr->Des()).Find(KScriptLF()));
+		if (lfPos != KErrNotFound)
+			{
+			(aHBufPtr->Des()).Replace(lfPos,2, KReplaceLF());
+			}
+			
+		}
+	while (lfPos != KErrNotFound );
+	
+	}
+	
+	
+	
+	
+
+	
+//parse and set the request or Response array 
+void CPipeliningTestParams::SetSequenceArrL(const TDesC& aRawRequestOrResponseArr, TInt aInt)
+	{
+	TInt jj;
+	TInt ii;
+	TInt arrMemberInt = -1;
+	RArray < TInt > aArray;
+	CleanupClosePushL(aArray);
+	ii = 0;
+	jj = 0;
+	if (aRawRequestOrResponseArr[jj] == ' ')
+		{
+		++jj;
+		}		
+	
+	TInt arrSize = aRawRequestOrResponseArr.Length();
+	for ( ii=0; ii < arrSize  ; ++ii )
+		{
+		if ( ( aRawRequestOrResponseArr[ii] == ',') ) //one integer, so process it
+			{
+			TPtrC intCharPtr = aRawRequestOrResponseArr.Mid ( jj, (ii - jj) );
+			TLex	intLex2SlicePtr( intCharPtr );
+			arrMemberInt = -1;
+			intLex2SlicePtr.Val(arrMemberInt);
+			
+			if ( aInt == ETransactionArray )
+				{
+				User::LeaveIfError(iTransArr.Append(arrMemberInt));
+				}
+			else
+				{
+				User::LeaveIfError(aArray.Append(arrMemberInt));
+				}
+				
+			jj = ii + 1;
+			if ( aRawRequestOrResponseArr[jj] == ' ' )
+				{
+					++jj;
+				}			
+			}			
+		}
+		
+	TInt lastInt;
+	TPtrC lastCharPtr = aRawRequestOrResponseArr.Mid ( jj, (aRawRequestOrResponseArr.Length() - jj ) );
+	TLex	lastIntLex2SlicePtr( lastCharPtr );
+	lastIntLex2SlicePtr.Val(lastInt);
+	
+	if ( aInt == ETransactionArray )
+		{
+		User::LeaveIfError(iTransArr.Append( lastInt ));
+		}
+	else
+		{
+		User::LeaveIfError(aArray.Append( lastInt ));
+		}
+		
+	
+	if ( aInt == ERequestArray )
+		{
+		User::LeaveIfError(iConnReq2DArr.Append( aArray ));
+		}		
+	else if ( aInt == EResponseArray )
+		{
+		User::LeaveIfError(iConnResp2DArr.Append( aArray ));
+		}
+	CleanupStack::Pop();
+	}
+
+
+
+
+
+//return the reqarr value
+TInt CPipeliningTestParams::TransactionSequenceArray(TInt aIndex) const
+	{
+	__ASSERT_ALWAYS( ((aIndex < iTransArr.Count()) && (aIndex >= 0)), User::Invariant());
+
+	return iTransArr[aIndex];
+	}
+	
+	
+	
+//Need to write this up
+void CPipeliningTestParams::ValidateL() const
+	{
+	TInt err = KErrNone;
+	TBool localUri = EFalse;
+	
+	// Are all mandatory fields present?
+	// TestCaseName
+	__ASSERT_ALWAYS((iTestCaseNameBuf->Des().Length() > 0), User::Leave(KErrGeneral));
+	
+	// Uri/Uri(n)
+	__ASSERT_ALWAYS(iUriBufArr.Count() > 0, User::Leave(KErrGeneral));
+
+	localUri = ((iUriBufArr.Count() == 1) && (((iUriBufArr[0]->Des()).Compare(_L8("http://127.0.0.1")) == 0) || ((iUriBufArr[0]->Des()).Compare(_L8("http://127.0.0.1/")) == 0)));
+	
+	// Pipelining or Batching
+	__ASSERT_ALWAYS((iPipeliningEnabled) || (iBatchingEnabled), User::Leave(KErrGeneral));	
+
+	// TotalTransactionCount
+	__ASSERT_ALWAYS(iTotalTransactionCount > 0, User::Leave(KErrGeneral));
+		
+	// TransArr
+	__ASSERT_ALWAYS(iTransArr.Count() == (iTotalTransactionCount), User::Leave(KErrGeneral));
+	
+	// ConnectionCount
+	__ASSERT_ALWAYS(((!(localUri) && (iConnectionCount == 0)) || (iConnectionCount > 0)), User::Leave(KErrGeneral));
+	
+	// RawRequest
+	// Greater than 0
+	__ASSERT_ALWAYS(iRawRequestBufArr.Count() > 0, User::Leave(KErrGeneral));
+	
+	// RawResponse
+	// Need not be there if connecting to external uri
+	// Single external uri 
+	__ASSERT_ALWAYS((localUri) || (iRawResponseBufArr.Count() > 0), User::Leave(KErrGeneral));
+/*			
+	if (localUri && iConnectionCount > 0 && !(iTestCaseNameBuf->Des().Compare(_L("Defect Fix INC036954")) == 0))
+		{
+		__ASSERT_ALWAYS(iConnReq2DArr.Count() == iConnectionCount, User::Leave(KErrGeneral));	
+		}	
+	// Are all optional fields correctly present?
+*/	
+	User::LeaveIfError( err );
+	}