diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericservices/httputils/Test/t_uriparser/CTextUtilsTest.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/ossrv/genericservices/httputils/Test/t_uriparser/CTextUtilsTest.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,604 @@
+// 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 "CTextUtilsTest.h"
+
+#include <uriutilscommon.h>
+#include <inetprottextutils.h>
+
+#include "TextUtilsTestCommon.h"
+#include "TextUtilsTests.h"
+
+CTextUtilsTest* CTextUtilsTest::NewLC(CIpuTestHarness* aTestHarness)
+	{
+	CTextUtilsTest* self = new (ELeave) CTextUtilsTest(aTestHarness);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	}
+
+CTextUtilsTest* CTextUtilsTest::NewL(CIpuTestHarness* aTestHarness)
+	{
+	CTextUtilsTest* self = CTextUtilsTest::NewLC(aTestHarness);
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CTextUtilsTest::CTextUtilsTest(CIpuTestHarness* aTestHarness)
+: iTestHarness(aTestHarness)
+	{
+	}
+
+void CTextUtilsTest::ConstructL()
+	{
+	}
+
+CTextUtilsTest::~CTextUtilsTest()
+	{
+	}
+
+void CTextUtilsTest::DoTestsL()
+	{
+
+	TestTextUtilsRemoveL(KRemove0_base, KRemove0_left, KRemove0_left_consumed,
+						KRemove0_right, KRemove0_right_consumed,
+						KRemove0_both, KRemove0_both_consumed);
+
+	TestTextUtilsDesToIntConversionL(KDecRep0, KNumericValue0, KIsValid0);
+	TestTextUtilsDesToIntConversionL(KDecRep1, KNumericValue1, KIsValid1);
+	TestTextUtilsDesToIntConversionL(KDecRep2, KNumericValue2, KIsValid2);
+	TestTextUtilsDesToIntConversionL(KDecRep3, KNumericValue3, KIsValid3);
+	
+	TestTextUtilsIntToDesConversionL(KNumericValue0, KDecRep0);
+	TestTextUtilsIntToDesConversionL(KNumericValue1, KDecRep1);
+
+	_LIT(KWhiteSpace," \t");
+	TestTextUtilsDesToHexConversionL(KWhiteSpace, 0, EFalse);
+
+	TestTextUtilsDesToHexConversionL(KHexRep0, KNumericValue0, KIsValid0);
+	TestTextUtilsDesToHexConversionL(KHexRep1, KNumericValue1, KIsValid1);
+	TestTextUtilsDesToHexConversionL(KHexRep2, KNumericValue2, KIsValid2);
+	TestTextUtilsDesToHexConversionL(KHexRep3, KNumericValue3, KIsValid3);
+
+	TestTextUtilsHexToDesConversionL(KNumericValue0, KHexRep0);
+	TestTextUtilsHexToDesConversionL(KNumericValue1, KHexRep1);
+
+	TestTextUtilsExtractQuotedStringL(KQuotedBuffer0, KQuotedString0, KQuotedRemainder0, KExpectedError0);
+	TestTextUtilsExtractQuotedStringL(KQuotedBuffer1, KQuotedString1, KQuotedRemainder1, KExpectedError1);
+	TestTextUtilsExtractQuotedStringL(KQuotedBuffer2, KQuotedString2, KQuotedRemainder2, KExpectedError2);
+	TestTextUtilsExtractQuotedStringL(KQuotedBuffer3, KQuotedString3, KQuotedRemainder3, KExpectedError3);
+
+	TestTextUtilsExtractTokenFromListL(
+									  KListBuffer0,
+									  KListToken0_0,
+									  KListToken0_1,
+									  KListToken0_2,
+									  KListRemainder0,
+									  KListSeparator0
+									  );
+
+	TestTextUtilsExtractTokenFromListL(
+									  KListBuffer1,
+									  KListToken1_0,
+									  KListToken1_1,
+									  KListToken1_2,
+									  KListRemainder1,
+									  KListSeparator1
+									  );
+
+	TestTextUtilsExtractTokenFromListL(
+									  KListBuffer2,
+									  KListToken2_0,
+									  KListToken2_1,
+									  KListToken2_2,
+									  KListRemainder2,
+									  KListSeparator2
+									  );
+
+	TestTextUtilsExtractTokenFromListL(
+									  KListBuffer3,
+									  KListToken3_0,
+									  KListToken3_1,
+									  KListToken3_2,
+									  KListRemainder3,
+									  KListSeparator3
+									  );
+	}
+
+void CTextUtilsTest::TestTextUtilsRemoveL(const TDesC& aBase, 
+										  const TDesC& aRemoveLeft, TInt aConsumedLeft,
+										  const TDesC& aRemoveRight, TInt aConsumedRight,
+										  const TDesC& aRemoveBoth, TInt aConsumedBoth)
+	{
+	iTestHarness->StartTestL(_L("Test TextUtils Remove (16-bit)"));
+
+	TInt error = DoTestTextUtilsRemove<TPtrC16>(aBase, aRemoveLeft, aConsumedLeft,
+												aRemoveRight, aConsumedRight,
+												aRemoveBoth, aConsumedBoth);
+
+	iTestHarness->EndTest(error);
+
+	// Make 8-bit copy
+	HBufC8* baseBuf = HBufC8::NewLC(aBase.Length());
+	TPtr8 base8Bit = baseBuf->Des();
+	base8Bit.Copy(aBase);
+
+	HBufC8* removeLeftBuf = HBufC8::NewLC(aRemoveLeft.Length());
+	TPtr8 removeLeft8Bit = removeLeftBuf->Des();
+	removeLeft8Bit.Copy(aRemoveLeft);
+
+	HBufC8* removeRightBuf = HBufC8::NewLC(aRemoveRight.Length());
+	TPtr8 removeRight8Bit = removeRightBuf->Des();
+	removeRight8Bit.Copy(aRemoveRight);
+
+	HBufC8* removeBothBuf = HBufC8::NewLC(aRemoveBoth.Length());
+	TPtr8 removeBoth8Bit = removeBothBuf->Des();
+	removeBoth8Bit.Copy(aRemoveBoth);
+
+	iTestHarness->StartTestL(_L("Test TextUtils Remove (8-bit)"));
+
+	error = DoTestTextUtilsRemove<TPtrC8>(base8Bit, removeLeft8Bit, aConsumedLeft,
+											removeRight8Bit, aConsumedRight,
+											removeBoth8Bit, aConsumedBoth);
+
+	iTestHarness->EndTest(error);
+
+	CleanupStack::PopAndDestroy(4, baseBuf);	// baseBuf, removeLeftBuf, removeRightBuf, removeBothBuf
+	}
+
+void CTextUtilsTest::TestTextUtilsDesToIntConversionL(const TDesC& aDes, TInt aInt, TBool aValid)
+	{
+	iTestHarness->StartTestL(_L("Test TextUtils ConvertDescriptorToInt (16-bit)"));
+
+	TInt error = DoTestTextUtilsDesToIntConversion(aDes, aInt, aValid);
+
+	iTestHarness->EndTest(error);
+
+	// Make 8-bit copy
+	HBufC8* desBuf = HBufC8::NewLC(aDes.Length());
+	TPtr8 des8Bit = desBuf->Des();
+	des8Bit.Copy(aDes);
+	
+	iTestHarness->StartTestL(_L("Test TextUtils ConvertDescriptorToInt (8-bit)"));
+
+	error = DoTestTextUtilsDesToIntConversion(des8Bit, aInt, aValid);
+
+	iTestHarness->EndTest(error);
+
+	CleanupStack::PopAndDestroy(desBuf);	// desBuf
+	}
+
+void CTextUtilsTest::TestTextUtilsIntToDesConversionL(TInt aInt, const TDesC& aDes)
+	{
+	iTestHarness->StartTestL(_L("Test TextUtils ConvertIntToDescriptor (16-bit)"));
+
+	TInt error = DoTestTextUtilsIntToDesConversion<HBufC16>(aInt, aDes);
+
+	iTestHarness->EndTest(error);
+
+	// Make 8-bit copy
+	HBufC8* desBuf = HBufC8::NewLC(aDes.Length());
+	TPtr8 des8Bit = desBuf->Des();
+	des8Bit.Copy(aDes);
+	
+	iTestHarness->StartTestL(_L("Test TextUtils ConvertIntToDescriptor (8-bit)"));
+
+	error = DoTestTextUtilsIntToDesConversion<HBufC8>(aInt, des8Bit);
+
+	iTestHarness->EndTest(error);
+
+	CleanupStack::PopAndDestroy(desBuf);	// desBuf
+	}
+
+
+
+void CTextUtilsTest::TestTextUtilsDesToHexConversionL(const TDesC& aDes, TInt aHexNumber, TBool aValid)
+	{
+	iTestHarness->StartTestL(_L("Test TextUtils ConvertDescriptorToHex (16-bit)"));
+
+	TInt error = DoTestTextUtilsDesToHexConversion(aDes, aHexNumber, aValid);
+	iTestHarness->EndTest(error);
+
+	// Test 8 bit version
+	TestTextUtilsDesToHexConversion8L(aDes, aHexNumber, aValid);
+	}
+	
+
+void CTextUtilsTest::TestTextUtilsDesToHexConversion8L(const TDesC& aDes, TInt aHexNumber, TBool aValid)
+	{
+	HBufC8* desBuf = HBufC8::NewLC(aDes.Length());
+	TPtr8 des8Bit = desBuf->Des();
+	des8Bit.Copy(aDes);
+	
+	iTestHarness->StartTestL(_L("Test TextUtils ConvertDescriptorToHex (8-bit)"));
+
+	TInt error = DoTestTextUtilsDesToHexConversion(des8Bit, aHexNumber, aValid);
+
+	iTestHarness->EndTest(error);
+
+	CleanupStack::PopAndDestroy(desBuf);	// desBuf
+	}
+	
+
+
+void CTextUtilsTest::TestTextUtilsHexToDesConversionL(TInt aHex, const TDesC& aDes)
+	{
+	iTestHarness->StartTestL(_L("Test TextUtils ConvertHexToDescriptor (16-bit)"));
+
+	TInt error = DoTestTextUtilsHexToDesConversion<HBufC16>(aHex, aDes);
+
+	iTestHarness->EndTest(error);
+
+	// Make 8-bit copy
+	HBufC8* desBuf = HBufC8::NewLC(aDes.Length());
+	TPtr8 des8Bit = desBuf->Des();
+	des8Bit.Copy(aDes);
+	
+	iTestHarness->StartTestL(_L("Test TextUtils ConvertHexToDescriptor (8-bit)"));
+
+	error = DoTestTextUtilsHexToDesConversion<HBufC8>(aHex, des8Bit);
+
+	iTestHarness->EndTest(error);
+
+	CleanupStack::PopAndDestroy(desBuf);	// desBuf
+	}
+
+void CTextUtilsTest::TestTextUtilsExtractQuotedStringL(
+													  const TDesC&	aBuffer, 
+													  const TDesC&	aString, 
+													  const TDesC&	aRemainder,
+													  TInt			aExpectedError
+													  )
+	{
+	iTestHarness->StartTestL(_L("Test TextUtils ExtractQuotedStringL (16-bit)"));
+
+	TInt error = DoTestExtractQuotedStringL<TPtrC>(aBuffer, aString, aRemainder, aExpectedError);
+
+	iTestHarness->EndTest(error);
+
+	// Make 8-bit copy
+	HBufC8* buffer = HBufC8::NewLC(aBuffer.Length());
+	buffer->Des().Copy(aBuffer);
+
+	HBufC8* string = HBufC8::NewLC(aString.Length());
+	string->Des().Copy(aString);
+
+	HBufC8* remainder = HBufC8::NewLC(aRemainder.Length());
+	remainder->Des().Copy(aRemainder);
+
+	iTestHarness->StartTestL(_L("Test TextUtils ExtractQuotedStringL (8-bit)"));
+
+	error = DoTestExtractQuotedStringL<TPtrC8>(*buffer, *string, *remainder, aExpectedError);
+
+	iTestHarness->EndTest(error);
+
+	CleanupStack::PopAndDestroy(3, buffer);
+	}
+
+void CTextUtilsTest::TestTextUtilsExtractTokenFromListL(
+													   const TDesC& aBuffer,
+													   const TDesC& aToken0,
+													   const TDesC& aToken1,
+													   const TDesC& aToken2,
+													   const TDesC& aRemainder,
+													   const TDesC& aSeparator
+													   )
+	{
+	iTestHarness->StartTestL(_L("Test TextUtils ExtractTokenFromList, multiple separator (16-bit)"));
+
+	TInt error = DoExtractTokenFromListMultipleSeparator<TPtrC>(aBuffer, aToken0, aToken1, aToken2, aRemainder, aSeparator);
+
+	iTestHarness->EndTest(error);
+
+	// Make 8-bit copy
+	HBufC8* buffer = HBufC8::NewLC(aBuffer.Length());
+	buffer->Des().Copy(aBuffer);
+
+	HBufC8* token0 = HBufC8::NewLC(aToken0.Length());
+	token0->Des().Copy(aToken0);
+
+	HBufC8* token1 = HBufC8::NewLC(aToken1.Length());
+	token1->Des().Copy(aToken1);
+
+	HBufC8* token2 = HBufC8::NewLC(aToken2.Length());
+	token2->Des().Copy(aToken2);
+
+	HBufC8* remainder = HBufC8::NewLC(aRemainder.Length());
+	remainder->Des().Copy(aRemainder);
+
+	HBufC8* separator = HBufC8::NewLC(aSeparator.Length());
+	separator->Des().Copy(aSeparator);
+
+	iTestHarness->StartTestL(_L("Test TextUtils ExtractTokenFromList, multiple separator (8-bit)"));
+
+	error = DoExtractTokenFromListMultipleSeparator<TPtrC8>(*buffer, *token0, *token1, *token2, *remainder, *separator);
+
+	iTestHarness->EndTest(error);
+
+	CleanupStack::PopAndDestroy(6, buffer);
+	}
+
+void CTextUtilsTest::TestTextUtilsExtractTokenFromListL(
+													   const TDesC& aBuffer,
+													   const TDesC& aToken0,
+													   const TDesC& aToken1,
+													   const TDesC& aToken2,
+													   const TDesC& aRemainder,
+													   TChar		aSeparator
+													   )
+	{
+	iTestHarness->StartTestL(_L("Test TextUtils ExtractTokenFromList, single separator (16-bit)"));
+
+	TInt error = DoExtractTokenFromListSingleSeparator<TPtrC>(aBuffer, aToken0, aToken1, aToken2, aRemainder, aSeparator);
+
+	iTestHarness->EndTest(error);
+
+	// Make 8-bit copy
+	HBufC8* buffer = HBufC8::NewLC(aBuffer.Length());
+	buffer->Des().Copy(aBuffer);
+
+	HBufC8* token0 = HBufC8::NewLC(aToken0.Length());
+	token0->Des().Copy(aToken0);
+
+	HBufC8* token1 = HBufC8::NewLC(aToken1.Length());
+	token1->Des().Copy(aToken1);
+
+	HBufC8* token2 = HBufC8::NewLC(aToken2.Length());
+	token2->Des().Copy(aToken2);
+
+	HBufC8* remainder = HBufC8::NewLC(aRemainder.Length());
+	remainder->Des().Copy(aRemainder);
+
+	iTestHarness->StartTestL(_L("Test TextUtils ExtractTokenFromList, single separator (8-bit)"));
+
+	error = DoExtractTokenFromListSingleSeparator<TPtrC8>(*buffer, *token0, *token1, *token2, *remainder, aSeparator);
+
+	iTestHarness->EndTest(error);
+
+	CleanupStack::PopAndDestroy(5, buffer);
+	}
+
+/*
+ *	Local methods
+ */
+
+template<class TPtrCType, class TDesCType>
+LOCAL_C TInt DoTestTextUtilsRemove(const TDesCType& aBase, 
+								   const TDesCType& aRemoveLeft, TInt aConsumedLeft,
+								   const TDesCType& aRemoveRight, TInt aConsumedRight,
+								   const TDesCType& aRemoveBoth, TInt aConsumedBoth)
+	{
+	// Do remove left...
+	TPtrCType data = aBase;
+	TInt consumed = InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveLeft);
+	// Check...
+	if( data.Compare(aRemoveLeft) != 0 || consumed != aConsumedLeft )
+		{
+		return KErrNotFound;
+		}
+	// Do remove right...
+	data.Set(aBase);
+	consumed = InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveRight);
+	// Check...
+	if( data.Compare(aRemoveRight) != 0 || consumed != aConsumedRight )
+		{
+		return KErrNotFound;
+		}
+	// Do remove both...
+	data.Set(aBase);
+	consumed = InetProtTextUtils::RemoveWhiteSpace(data, InetProtTextUtils::ERemoveBoth);
+	// Check...
+	if( data.Compare(aRemoveBoth) != 0 || consumed != aConsumedBoth )
+		{
+		return KErrNotFound;
+		}
+	return KErrNone;
+	}
+
+template<class TDesCType>
+LOCAL_C TInt DoTestTextUtilsDesToIntConversion(const TDesCType& aDes, TInt aInt, TBool aValid)
+	{
+	TInt theInt;
+	TInt error = InetProtTextUtils::ConvertDescriptorToInt(aDes, theInt);
+	if( (error < KErrNone && aValid) || (error >= KErrNone && !aValid) )
+		{
+		return KErrNotFound;
+		}
+	if( aValid && theInt != aInt )
+		{
+		return KErrNotFound;
+		}
+	return KErrNone;
+	}
+
+template<class HBufCType, class TDesCType>
+LOCAL_C TInt DoTestTextUtilsIntToDesConversion(TInt aInt, const TDesCType& aDes)
+	{
+	HBufCType* theDes = NULL;
+	TRAPD(error, InetProtTextUtils::ConvertIntToDescriptorL(aInt, theDes));
+	if( error != KErrNone )
+		{
+		return KErrNotFound;
+		}
+	if( theDes->CompareF(aDes) != 0 )
+		{
+		delete theDes;
+		return KErrNotFound;
+		}
+	delete theDes;
+	return KErrNone;
+	}
+
+template<class TDesCType>
+LOCAL_C TInt DoTestTextUtilsDesToHexConversion(const TDesCType& aDes, TInt aHex, TBool aValid)
+	{
+	TInt theHex;
+	TInt error = InetProtTextUtils::ConvertDescriptorToHex(aDes, theHex);
+	if( (error < KErrNone && aValid) || (error >= KErrNone && !aValid) )
+		{
+		return KErrNotFound;
+		}
+	if( aValid && theHex != aHex )
+		{
+		return KErrNotFound;
+		}
+	return KErrNone;
+	}
+
+template<class HBufCType, class TDesCType>
+LOCAL_C TInt DoTestTextUtilsHexToDesConversion(TInt aHex, const TDesCType& aDes)
+	{
+	HBufCType* theDes = NULL;
+	TRAPD(error, InetProtTextUtils::ConvertHexToDescriptorL(aHex, theDes));
+	if( error != KErrNone )
+		{
+		return KErrNotFound;
+		}
+	if( theDes->CompareF(aDes) != 0 )
+		{
+		delete theDes;
+		return KErrNotFound;
+		}
+	delete theDes;
+	return KErrNone;
+	}
+
+template<class TPtrCType, class TDesCType>
+LOCAL_C TInt DoTestExtractQuotedStringL(const TDesCType& aBuffer, const TDesCType& aString, const TDesCType& aRemainder, TInt aExpectedError)
+	{
+	TPtrCType buffer(aBuffer);
+	TPtrCType string;
+	TRAPD( error, InetProtTextUtils::ExtractQuotedStringL(buffer, string) );
+
+	if( error == KErrNone && aExpectedError == KErrNone)
+		{
+		if( aString.Compare(string) == 0 && aRemainder.Compare(buffer) == 0 )
+			{
+			// Passed
+			return KErrNone;
+			}
+		else
+			{
+			// Failed
+			return KErrNotFound;
+			}
+		}
+	else if( error == aExpectedError )
+		{
+		// Got expected error - passed
+		return KErrNone;
+		}
+	else
+		{
+		// Failed
+		return KErrNotFound;
+		}
+	}
+
+template<class TPtrCType, class TDesCType>
+LOCAL_C TInt DoExtractTokenFromListMultipleSeparator(
+												const TDesCType& aBuffer,
+												const TDesCType& aToken0,
+												const TDesCType& aToken1,
+												const TDesCType& aToken2,
+												const TDesCType& aRemainder,
+												const TDesCType& aSeparator
+												)
+	{
+	// get the first token...
+	TPtrCType buffer = aBuffer;
+	TPtrCType token;
+	InetProtTextUtils::ExtractNextTokenFromList(buffer, token, aSeparator);
+
+	// Is it correct?
+	if( token.Compare(aToken0) != 0 )
+		{
+		// Failed
+		return KErrNotFound;
+		}
+	// get the second token
+	InetProtTextUtils::ExtractNextTokenFromList(buffer, token, aSeparator);
+
+	// Is it correct?
+	if( token.Compare(aToken1) != 0 )
+		{
+		// Failed
+		return KErrNotFound;
+		}
+	// get the third token
+	InetProtTextUtils::ExtractNextTokenFromList(buffer, token, aSeparator);
+
+	// Is it correct?
+	if( token.Compare(aToken2) != 0 )
+		{
+		// Failed
+		return KErrNotFound;
+		}
+	// Check that the remainder is correct
+	if( buffer.Compare(aRemainder) != 0 )
+		{
+		// Failed
+		return KErrNotFound;
+		}
+	return KErrNone;
+	}
+
+template<class TPtrCType, class TDesCType>
+LOCAL_C TInt DoExtractTokenFromListSingleSeparator(
+												const TDesCType& aBuffer,
+												const TDesCType& aToken0,
+												const TDesCType& aToken1,
+												const TDesCType& aToken2,
+												const TDesCType& aRemainder,
+												TChar			 aSeparator
+												)
+	{
+	// get the first token...
+	TPtrCType buffer = aBuffer;
+	TPtrCType token;
+	InetProtTextUtils::ExtractNextTokenFromList(buffer, token, aSeparator);
+
+	// Is it correct?
+	if( token.Compare(aToken0) != 0 )
+		{
+		// Failed
+		return KErrNotFound;
+		}
+	// get the second token
+	InetProtTextUtils::ExtractNextTokenFromList(buffer, token, aSeparator);
+
+	// Is it correct?
+	if( token.Compare(aToken1) != 0 )
+		{
+		// Failed
+		return KErrNotFound;
+		}
+	// get the third token
+	InetProtTextUtils::ExtractNextTokenFromList(buffer, token, aSeparator);
+
+	// Is it correct?
+	if( token.Compare(aToken2) != 0 )
+		{
+		// Failed
+		return KErrNotFound;
+		}
+	// Check that the remainder is correct
+	if( buffer.Compare(aRemainder) != 0 )
+		{
+		// Failed
+		return KErrNotFound;
+		}
+	return KErrNone;
+	}