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; + }