diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericservices/httputils/Test/t_uriparser/CEscapeUtilsTest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericservices/httputils/Test/t_uriparser/CEscapeUtilsTest.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,392 @@ +// 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 "CEscapeUtilsTest.h" + +#include + +#include "EscapeUtilsTestCommon.h" +#include "EscapeUtilsTests.h" +#include + +CEscapeUtilsTest* CEscapeUtilsTest::NewLC(CIpuTestHarness* aTestHarness) + { + CEscapeUtilsTest* self = new (ELeave) CEscapeUtilsTest(aTestHarness); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CEscapeUtilsTest* CEscapeUtilsTest::NewL(CIpuTestHarness* aTestHarness) + { + CEscapeUtilsTest* self = CEscapeUtilsTest::NewLC(aTestHarness); + CleanupStack::Pop(self); + return self; + } + +CEscapeUtilsTest::CEscapeUtilsTest(CIpuTestHarness* aTestHarness) +: iTestHarness(aTestHarness) + { + } + +void CEscapeUtilsTest::ConstructL() + { + } + +CEscapeUtilsTest::~CEscapeUtilsTest() + { + } + +void CEscapeUtilsTest::DoTestsL() + { + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded0, KEscapeEncoded0_auth, EscapeUtils::EEscapeAuth); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded0, KEscapeEncoded0_path, EscapeUtils::EEscapePath); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded0, KEscapeEncoded0_query, EscapeUtils::EEscapeQuery); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded0, KEscapeEncoded0_normal, EscapeUtils::EEscapeNormal); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded0, KEscapeEncoded0_url, EscapeUtils::EEscapeUrlEncoded); + + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded1, KEscapeEncoded1_auth, EscapeUtils::EEscapeAuth); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded1, KEscapeEncoded1_path, EscapeUtils::EEscapePath); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded1, KEscapeEncoded1_query, EscapeUtils::EEscapeQuery); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded1, KEscapeEncoded1_normal, EscapeUtils::EEscapeNormal); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded1, KEscapeEncoded1_url, EscapeUtils::EEscapeUrlEncoded); + + + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded0_auth, KEscapeDecoded0); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded0_path, KEscapeDecoded0); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded0_query, KEscapeDecoded0); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded0_normal, KEscapeDecoded0); + + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded1_auth, KEscapeDecoded1); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded1_path, KEscapeDecoded1); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded1_query, KEscapeDecoded1); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded1_normal, KEscapeDecoded1); + + // Test cases for section 2.9.1.2 // + + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded2, KEscapeEncoded2_auth, EscapeUtils::EEscapeAuth); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded2, KEscapeEncoded2_path, EscapeUtils::EEscapePath); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded2, KEscapeEncoded2_query, EscapeUtils::EEscapeQuery); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded2, KEscapeEncoded2_normal, EscapeUtils::EEscapeNormal); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded2, KEscapeEncoded2_url, EscapeUtils::EEscapeUrlEncoded); + + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded3, KEscapeEncoded3_auth, EscapeUtils::EEscapeAuth); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded3, KEscapeEncoded3_path, EscapeUtils::EEscapePath); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded3, KEscapeEncoded3_query, EscapeUtils::EEscapeQuery); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded3, KEscapeEncoded3_normal, EscapeUtils::EEscapeNormal); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded3, KEscapeEncoded3_url, EscapeUtils::EEscapeUrlEncoded); + + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded4, KEscapeEncoded4_auth, EscapeUtils::EEscapeAuth); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded4, KEscapeEncoded4_path, EscapeUtils::EEscapePath); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded4, KEscapeEncoded4_query, EscapeUtils::EEscapeQuery); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded4, KEscapeEncoded4_normal, EscapeUtils::EEscapeNormal); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded4, KEscapeEncoded4_url, EscapeUtils::EEscapeUrlEncoded); + + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded5, KEscapeEncoded5_auth, EscapeUtils::EEscapeAuth); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded5, KEscapeEncoded5_path, EscapeUtils::EEscapePath); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded5, KEscapeEncoded5_query, EscapeUtils::EEscapeQuery); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded5, KEscapeEncoded5_normal, EscapeUtils::EEscapeNormal); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded5, KEscapeEncoded5_url, EscapeUtils::EEscapeUrlEncoded); + + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded6, KEscapeEncoded6_auth, EscapeUtils::EEscapeAuth); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded6, KEscapeEncoded6_path, EscapeUtils::EEscapePath); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded6, KEscapeEncoded6_query, EscapeUtils::EEscapeQuery); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded6, KEscapeEncoded6_normal, EscapeUtils::EEscapeNormal); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded6, KEscapeEncoded6_url, EscapeUtils::EEscapeUrlEncoded); + + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded7, KEscapeEncoded7_auth, EscapeUtils::EEscapeAuth); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded7, KEscapeEncoded7_path, EscapeUtils::EEscapePath); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded7, KEscapeEncoded7_query, EscapeUtils::EEscapeQuery); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded7, KEscapeEncoded7_normal, EscapeUtils::EEscapeNormal); + TestEscapeUtilsEscapeEncodeL(KEscapeDecoded7, KEscapeEncoded7_url, EscapeUtils::EEscapeUrlEncoded); + + + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded2_auth, KEscapeDecoded2); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded2_path, KEscapeDecoded2); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded2_query, KEscapeDecoded2); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded2_normal, KEscapeDecoded2); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded2_url, KEscapeDecoded2); + + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded3_auth, KEscapeDecoded3); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded3_path, KEscapeDecoded3); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded3_query, KEscapeDecoded3); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded3_normal, KEscapeDecoded3); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded3_url, KEscapeDecoded3); + + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded4_auth, KEscapeDecoded4); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded4_path, KEscapeDecoded4); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded4_query, KEscapeDecoded4); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded4_normal, KEscapeDecoded4); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded4_url, KEscapeDecoded4); + + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded5_auth, KEscapeDecoded5); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded5_path, KEscapeDecoded5); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded5_query, KEscapeDecoded5); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded5_normal, KEscapeDecoded5); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded5_url, KEscapeDecoded5); + + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded6_auth, KEscapeDecoded6); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded6_path, KEscapeDecoded6); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded6_query, KEscapeDecoded6); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded6_normal, KEscapeDecoded6); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded6_url, KEscapeDecoded6); + + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded7_auth, KEscapeDecoded7); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded7_path, KEscapeDecoded7); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded7_query, KEscapeDecoded7); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded7_normal, KEscapeDecoded7); + TestEscapeUtilsEscapeDecodeL(KEscapeEncoded7_url, KEscapeDecoded7); + + // + + TestEscapeUtilsUnicodeUtf8ConversionsL(KUnicode_0, KUtf8_0); + + TestEscapeUtilsIsExcludedCharL(KExcludedChar0, KExcludedChar0_excluded); + TestEscapeUtilsIsExcludedCharL(KExcludedChar1, KExcludedChar1_excluded); + TestEscapeUtilsIsExcludedCharL(KExcludedChar2, KExcludedChar2_excluded); + TestEscapeUtilsIsExcludedCharL(KExcludedChar3, KExcludedChar3_excluded); + TestEscapeUtilsIsExcludedCharL(KExcludedChar4, KExcludedChar4_excluded); + + TestEscapeUtilsIsEscapeTripleL(KEscapeTriple0(), KEscapeTriple0_valid, KEscapeTriple0_value); + TestEscapeUtilsIsEscapeTripleL(KEscapeTriple1(), KEscapeTriple1_valid, KEscapeTriple1_value); + TestEscapeUtilsIsEscapeTripleL(KEscapeTriple2(), KEscapeTriple2_valid, KEscapeTriple2_value); + + //TConvBase64 Test + TestEscapeUtilsBase64ConversionL(KEscapeDecoded2); + } + +void CEscapeUtilsTest::TestEscapeUtilsEscapeEncodeL(const TDesC& aData, const TDesC& aExpected, EscapeUtils::TEscapeMode aEscapeMode) + { + iTestHarness->StartTestL(_L("Test EscapeUtils EscapeEncode (16-bit)")); + + TInt error = DoTestEscapeUtilsEscapeEncode(aData, aExpected, aEscapeMode); + + iTestHarness->EndTest(error); + + // Make 8-bit copy + HBufC8* dataBuf = HBufC8::NewLC(aData.Length()); + TPtr8 data8Bit = dataBuf->Des(); + data8Bit.Copy(aData); + + HBufC8* expectedBuf = HBufC8::NewLC(aExpected.Length()); + TPtr8 expected8Bit = expectedBuf->Des(); + expected8Bit.Copy(aExpected); + + iTestHarness->StartTestL(_L("Test EscapeUtils EscapeEncode (8-bit)")); + + error = DoTestEscapeUtilsEscapeEncode(data8Bit, expected8Bit, aEscapeMode); + + iTestHarness->EndTest(error); + + CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, expectedBuf + } + +void CEscapeUtilsTest::TestEscapeUtilsEscapeDecodeL(const TDesC& aData, const TDesC& aExpected) + { + iTestHarness->StartTestL(_L("Test EscapeUtils EscapeDecode (16-bit)")); + + TInt error = DoTestEscapeUtilsEscapeDecode(aData, aExpected); + + iTestHarness->EndTest(error); + + // Make 8-bit copy + HBufC8* dataBuf = HBufC8::NewLC(aData.Length()); + TPtr8 data8Bit = dataBuf->Des(); + data8Bit.Copy(aData); + + HBufC8* expectedBuf = HBufC8::NewLC(aExpected.Length()); + TPtr8 expected8Bit = expectedBuf->Des(); + expected8Bit.Copy(aExpected); + + iTestHarness->StartTestL(_L("Test EscapeUtils EscapeDecode (8-bit)")); + + error = DoTestEscapeUtilsEscapeDecode(data8Bit, expected8Bit); + + iTestHarness->EndTest(error); + + CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, expectedBuf + } + +void CEscapeUtilsTest::TestEscapeUtilsUnicodeUtf8ConversionsL(const TDesC& aUnicode, const TDesC& aUtf8) + { + // Make 8-bit copy of utf8 + HBufC8* utf8Buf = HBufC8::NewLC(aUtf8.Length()); + utf8Buf->Des().Copy(aUtf8); + + // Escape decode + HBufC8* unescapedUtf8Buf = EscapeUtils::EscapeDecodeL(*utf8Buf); + CleanupStack::PushL(unescapedUtf8Buf); + TPtr8 unescapedUtf8 = unescapedUtf8Buf->Des(); + + iTestHarness->StartTestL(_L("Test EscapeUtils ConvertFromUnicodeToUtf8")); + + HBufC8* convertedUtf8 = NULL; + TRAPD(error, convertedUtf8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aUnicode)); + if( error == KErrNone ) + { + // Check is expected + if( convertedUtf8->Compare(unescapedUtf8) != 0 ) + { + error = KErrNotFound; + } + delete convertedUtf8; + } + iTestHarness->EndTest(error); + + iTestHarness->StartTestL(_L("Test EscapeUtils ConvertToUnicodeFromUtf8")); + + HBufC16* convertedUnicode = NULL; + TRAP(error, convertedUnicode = EscapeUtils::ConvertToUnicodeFromUtf8L(unescapedUtf8)); + if( error == KErrNone ) + { + // Check is expected + if( convertedUnicode->Compare(aUnicode) != 0 ) + { + error = KErrNotFound; + } + delete convertedUnicode; + } + iTestHarness->EndTest(error); + + CleanupStack::PopAndDestroy(2, utf8Buf); // utf8Buf, unescapedUtf8Buf + } + +void CEscapeUtilsTest::TestEscapeUtilsIsExcludedCharL(TChar aChar, TBool aIsExcluded) + { + iTestHarness->StartTestL(_L("Test EscapeUtils IsExcludedChar")); + + TBool excluded = EscapeUtils::IsExcludedChar(aChar); + + TInt error = KErrNone; + if( (!excluded && aIsExcluded) | (excluded && !aIsExcluded) ) + { + error = KErrNotFound; + } + iTestHarness->EndTest(error); + } + +void CEscapeUtilsTest::TestEscapeUtilsIsEscapeTripleL(const TDesC& aData, TBool aIsTriple, TInt aValue) + { + iTestHarness->StartTestL(_L("Test EscapeUtils IsEscapeTriple (16-Bit)")); + + TInt error = DoTestEscapeUtilsIsEscapeTriple(aData, aIsTriple, aValue); + + iTestHarness->EndTest(error); + + // Make 8-bit copy + HBufC8* dataBuf = HBufC8::NewLC(aData.Length()); + TPtr8 data8Bit = dataBuf->Des(); + data8Bit.Copy(aData); + + iTestHarness->StartTestL(_L("Test EscapeUtils IsEscapeTriple (8-Bit)")); + + error = DoTestEscapeUtilsIsEscapeTriple(data8Bit, aIsTriple, aValue); + + iTestHarness->EndTest(error); + + CleanupStack::PopAndDestroy(dataBuf); // dataBuf + } + +void CEscapeUtilsTest::TestEscapeUtilsBase64ConversionL(const TDesC& aData) + { + iTestHarness->StartTestL(_L("Test EscapeUtils Base64 Conversion Check")); + + TInt error = KErrNotFound; + HBufC8* dataBuf = HBufC8::NewMaxLC (aData.Length()); + TPtr8 dataPtr(dataBuf->Des()); + + HBufC8* encodedBuf = HBufC8::NewMaxLC(aData.Length() * 2); + TPtr8 encodedPtr(encodedBuf->Des()); + + TBase64 codec; + codec.Encode(dataPtr, encodedPtr); + + HBufC8* decodedBuf = HBufC8::NewMaxLC(aData.Length()); + TPtr8 decodedPtr(decodedBuf->Des()); + + codec.Decode(encodedPtr, decodedPtr); + if(decodedPtr.Compare(dataPtr) == 0) + { + error = KErrNone; + } + iTestHarness->EndTest(error); + + CleanupStack::PopAndDestroy(decodedBuf); // decodedBuf + CleanupStack::PopAndDestroy(encodedBuf); // encodedBuf + CleanupStack::PopAndDestroy(dataBuf); // dataBuf + } + +// +// +// Implementation of LOCAL functions +// +// + +template +LOCAL_C TInt DoTestEscapeUtilsEscapeEncode(const TDesCType& aData, const TDesCType& aExpected, EscapeUtils::TEscapeMode aEscapeMode) + { + // Do escaping + HBufCType* escaped = NULL; + TRAPD(error, escaped = EscapeUtils::EscapeEncodeL(aData, aEscapeMode)); + if( error != KErrNone ) + { + return KErrNotFound; + } + // Check with expected + if( escaped->Compare(aExpected) != 0 ) + { + delete escaped; + return KErrNotFound; + } + delete escaped; + return KErrNone; + } + +template +LOCAL_C TInt DoTestEscapeUtilsEscapeDecode(const TDesCType& aData, const TDesCType& aExpected) + { + // Do unescaping + HBufCType* unescaped = NULL; + TRAPD(error, unescaped = EscapeUtils::EscapeDecodeL(aData)); + if( error != KErrNone ) + { + return KErrNotFound; + } + // Check with expected + if( unescaped->Compare(aExpected) != 0 ) + { + delete unescaped; + return KErrNotFound; + } + delete unescaped; + return KErrNone; + } + +template +LOCAL_C TInt DoTestEscapeUtilsIsEscapeTriple(const TDesCType& aData, TBool aIsTriple, TInt aValue) + { + // Check for the triple + TInt value; + TBool triple = EscapeUtils::IsEscapeTriple(aData, value); + if( (!triple && aIsTriple) | (triple && !aIsTriple) ) + { + return KErrNotFound; + } + if( triple && value != aValue ) + { + return KErrNotFound; + } + return KErrNone; + }