sl@0: /*
sl@0: * Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: * All rights reserved.
sl@0: * This component and the accompanying materials are made available
sl@0: * under the terms of "Eclipse Public License v1.0"
sl@0: * which accompanies this distribution, and is available
sl@0: * at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: *
sl@0: * Initial Contributors:
sl@0: * Nokia Corporation - initial contribution.
sl@0: *
sl@0: * Contributors:
sl@0: *
sl@0: * Description:
sl@0: *
sl@0: */
sl@0:
sl@0:
sl@0: #include <e32std.h>
sl@0: #include <utf.h>
sl@0: #include "t_partial.h"
sl@0:
sl@0: #define test(cond) \
sl@0: { \
sl@0: TBool __bb = (cond); \
sl@0: TEST(__bb); \
sl@0: if (!__bb) \
sl@0: { \
sl@0: ERR_PRINTF1(_L("ERROR: Test Failed")); \
sl@0: User::Leave(1); \
sl@0: } \
sl@0: }
sl@0:
sl@0:
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0:
sl@0: const TInt KUtfBufferLength=100;
sl@0: const TUint KIllegalUtfByteValue=0xff;
sl@0: const TUint KIllegalUnicodeCharacter=0xffff;
sl@0:
sl@0: LOCAL_C void FillWithIllegalUtf(TUint8* aUtfBuffer)
sl@0: {
sl@0: for (TInt i=0; i<KUtfBufferLength; ++i)
sl@0: {
sl@0: aUtfBuffer[i]=KIllegalUtfByteValue;
sl@0: }
sl@0: }
sl@0:
sl@0: LOCAL_C TBool FillWithIllegalUtfReturningIfMatched(TUint8* aUtfBuffer, const TDes8& aDescriptorAroundBuffer, const TDesC8& aUtfToMatch)
sl@0: {
sl@0: __ASSERT_ALWAYS(aDescriptorAroundBuffer.Ptr()==aUtfBuffer, User::Panic(_L("TPARTIAL"), 0));
sl@0: __ASSERT_ALWAYS(aDescriptorAroundBuffer.MaxLength()>=aUtfToMatch.Length(), User::Panic(_L("TPARTIAL"), 1));
sl@0: __ASSERT_ALWAYS(aDescriptorAroundBuffer.MaxLength()<=KUtfBufferLength, User::Panic(_L("TPARTIAL"), 2));
sl@0: TBool matched=TPtrC8(aUtfBuffer, aUtfToMatch.Length())==aUtfToMatch;
sl@0: if (matched)
sl@0: {
sl@0: for (TInt i=aDescriptorAroundBuffer.MaxLength(); i<KUtfBufferLength; ++i)
sl@0: {
sl@0: if (aUtfBuffer[i]!=KIllegalUtfByteValue)
sl@0: {
sl@0: matched=EFalse;
sl@0: break;
sl@0: }
sl@0: }
sl@0: }
sl@0: FillWithIllegalUtf(aUtfBuffer);
sl@0: return matched;
sl@0: }
sl@0:
sl@0: LOCAL_C void FillWithIllegalUnicode(TUint16* aUnicodeBuffer)
sl@0: {
sl@0: for (TInt i=0; i<KUtfBufferLength; ++i)
sl@0: {
sl@0: aUnicodeBuffer[i]=KIllegalUnicodeCharacter;
sl@0: }
sl@0: }
sl@0:
sl@0: LOCAL_C TBool FillWithIllegalUnicodeReturningIfMatched(TUint16* aUnicodeBuffer, const TDesC16& aUnicodeToMatch)
sl@0: {
sl@0: const TInt lengthToMatch=aUnicodeToMatch.Length();
sl@0: TBool matched=TPtrC16(aUnicodeBuffer, lengthToMatch)==aUnicodeToMatch;
sl@0: if (matched)
sl@0: {
sl@0: for (TInt i=lengthToMatch; i<KUtfBufferLength; ++i)
sl@0: {
sl@0: if (aUnicodeBuffer[i]!=KIllegalUnicodeCharacter)
sl@0: {
sl@0: matched=EFalse;
sl@0: break;
sl@0: }
sl@0: }
sl@0: }
sl@0: FillWithIllegalUnicode(aUnicodeBuffer);
sl@0: return matched;
sl@0: }
sl@0: /**
sl@0: @SYMTestCaseID SYSLIB-CHARCONV-CT-0572
sl@0: @SYMTestCaseDesc Tests that partial conversions work
sl@0: @SYMTestPriority Medium
sl@0: @SYMTestActions Tests for converting to Unicode from UTF- 7
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ REQ0000
sl@0: */
sl@0: void CT_PARTIAL::TestConvertingToUtf(TUint8* aUtfBuffer, TInt aMaximumLengthOfUtfDescriptor, const TDesC16& aUnicode, TBool aBoolParameter, TInt aNumberOfUnicodeItemsExpectedToBeConverted, const TDesC8& aFirstHalfOfUtfExpected, const TDesC8& aSecondHalfOfUtfExpected)
sl@0: {
sl@0: INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0572 "));
sl@0: TPtr8 utf(aUtfBuffer, aMaximumLengthOfUtfDescriptor);
sl@0: FillWithIllegalUtf(aUtfBuffer);
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf7(utf, aUnicode, aBoolParameter)==aNumberOfUnicodeItemsExpectedToBeConverted);
sl@0: test(FillWithIllegalUtfReturningIfMatched(aUtfBuffer, utf, aFirstHalfOfUtfExpected));
sl@0: TPtr8 restOfUtf(aUtfBuffer, KUtfBufferLength);
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf7(restOfUtf, aUnicode.Right(aNumberOfUnicodeItemsExpectedToBeConverted), aBoolParameter)==0);
sl@0: test(FillWithIllegalUtfReturningIfMatched(aUtfBuffer, restOfUtf, aSecondHalfOfUtfExpected));
sl@0: TBuf8<KUtfBufferLength> originalUtf(aFirstHalfOfUtfExpected);
sl@0: originalUtf.Append(aSecondHalfOfUtfExpected);
sl@0: TBuf16<20> generatedUnicode;
sl@0: TInt state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, originalUtf, state)==0);
sl@0: test(state==CnvUtfConverter::KStateDefault);
sl@0: test(generatedUnicode==aUnicode);
sl@0: }
sl@0: /**
sl@0: @SYMTestCaseID SYSLIB-CHARCONV-CT-0573
sl@0: @SYMTestCaseDesc Tests that partial conversions work
sl@0: @SYMTestPriority Medium
sl@0: @SYMTestActions Tests for converting to Unicode from UTF- 7
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ REQ0000
sl@0: */
sl@0: void CT_PARTIAL::TestUtf7StatePreservation(const TDesC8& aUtf7)
sl@0: {
sl@0: INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0573 "));
sl@0: TInt state=CnvUtfConverter::KStateDefault;
sl@0: TBuf16<50> wholeGeneratedUnicode;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(wholeGeneratedUnicode, aUtf7, state)==0);
sl@0: for (TInt i=aUtf7.Length()-1; i>=0; --i)
sl@0: {
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: TBuf16<50> generatedUnicode1;
sl@0: TInt numberOfUtf7BytesNotConvertedByFirstCall=CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode1, aUtf7.Left(i), state);
sl@0: if (numberOfUtf7BytesNotConvertedByFirstCall<0)
sl@0: {
sl@0: test(numberOfUtf7BytesNotConvertedByFirstCall==CnvUtfConverter::EErrorIllFormedInput);
sl@0: numberOfUtf7BytesNotConvertedByFirstCall=i;
sl@0: generatedUnicode1=KNullDesC16;
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: }
sl@0: test(numberOfUtf7BytesNotConvertedByFirstCall>=0);
sl@0: TBuf16<50> generatedUnicode2;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode2, aUtf7.Mid(i-numberOfUtf7BytesNotConvertedByFirstCall), state)==0);
sl@0: generatedUnicode1+=generatedUnicode2;
sl@0: test(generatedUnicode1==wholeGeneratedUnicode);
sl@0: }
sl@0: }
sl@0:
sl@0: void CT_PARTIAL::TestConvertingToUtf(TUint8* aUtfBuffer, TInt aMaximumLengthOfUtfDescriptor, const TDesC16& aUnicode, TInt aNumberOfUnicodeItemsExpectedToBeConverted, const TDesC8& aFirstHalfOfUtfExpected, const TDesC8& aSecondHalfOfUtfExpected)
sl@0: {
sl@0: TestConvertingToUtf(aUtfBuffer, aMaximumLengthOfUtfDescriptor, aUnicode, EFalse, aNumberOfUnicodeItemsExpectedToBeConverted, aFirstHalfOfUtfExpected, aSecondHalfOfUtfExpected);
sl@0: }
sl@0:
sl@0: void CT_PARTIAL::TestPARTIAL()
sl@0: {
sl@0: INFO_PRINTF1(_L("Checking that partial conversions work"));
sl@0: TUint8 utfBuffer[KUtfBufferLength];
sl@0: TUint16 unicodeBuffer[KUtfBufferLength];
sl@0: INFO_PRINTF1(_L("Testing trivial UTF-7 and UTF-8"));
sl@0: {
sl@0: for (TInt i=0; i<6; ++i)
sl@0: {
sl@0: const TInt numberOfUnconvertedItemsAtEndOfInputDescriptor=5-i;
sl@0: TPtr8 utf(utfBuffer, i);
sl@0: FillWithIllegalUtf(utfBuffer);
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf7(utf, _L16("abcde"), EFalse)==numberOfUnconvertedItemsAtEndOfInputDescriptor);
sl@0: test(FillWithIllegalUtfReturningIfMatched(utfBuffer, utf, _L8("abcde").Left(i)));
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf7(utf, _L16("abcde"), ETrue)==numberOfUnconvertedItemsAtEndOfInputDescriptor);
sl@0: test(FillWithIllegalUtfReturningIfMatched(utfBuffer, utf, _L8("abcde").Left(i)));
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf8(utf, _L16("abcde"))==numberOfUnconvertedItemsAtEndOfInputDescriptor);
sl@0: test(FillWithIllegalUtfReturningIfMatched(utfBuffer, utf, _L8("abcde").Left(i)));
sl@0: TPtr16 unicode(unicodeBuffer, i);
sl@0: TInt state=CnvUtfConverter::KStateDefault;
sl@0: FillWithIllegalUnicode(unicodeBuffer);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(unicode, _L8("abcde"), state)==numberOfUnconvertedItemsAtEndOfInputDescriptor);
sl@0: test(FillWithIllegalUnicodeReturningIfMatched(unicodeBuffer, _L16("abcde").Left(i)));
sl@0: test(state==CnvUtfConverter::KStateDefault);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(unicode, _L8("abcde"))==numberOfUnconvertedItemsAtEndOfInputDescriptor);
sl@0: test(FillWithIllegalUnicodeReturningIfMatched(unicodeBuffer, _L16("abcde").Left(i)));
sl@0: }
sl@0: }
sl@0: INFO_PRINTF1(_L("Testing converting to UTF-7"));
sl@0: {
sl@0: TBuf16<20> originalUnicode;
sl@0: TBuf16<20> generatedUnicode;
sl@0: TBuf8<20> generatedUtf;
sl@0: originalUnicode.Format(_L16("%c%c%c%c?"), 0x8fd9, 0x662f, 0x4ec0, 0x4e48); // Chinese: zhe4 shi4 shen2 me?
sl@0: TInt i;
sl@0: for (i=0; i<=4; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 5, KNullDesC8, _L8("+j9lmL07ATkg-?"));
sl@0: }
sl@0: for (i=5; i<=7; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 4, _L8("+j9k-"), _L8("+Zi9OwE5I-?"));
sl@0: }
sl@0: for (i=8; i<=9; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 3, _L8("+j9lmLw-"), _L8("+TsBOSA-?"));
sl@0: }
sl@0: for (i=10; i<=12; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 2, _L8("+j9lmL07A-"), _L8("+Tkg-?"));
sl@0: }
sl@0: TestConvertingToUtf(utfBuffer, 13, originalUnicode, 1, _L8("+j9lmL07ATkg-"), _L8("?"));
sl@0: TestConvertingToUtf(utfBuffer, 14, originalUnicode, 0, _L8("+j9lmL07ATkg-?"), KNullDesC8);
sl@0: originalUnicode.Format(_L16("%c %c%c %c%c%c%c."), 0x042f, 0x043d, 0x0435, 0x0437, 0x043d, 0x0430, 0x044e); // Russian: ya nye znayu.
sl@0: for (i=0; i<=4; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 10, KNullDesC8, _L8("+BC8- +BD0ENQ- +BDcEPQQwBE4-."));
sl@0: }
sl@0: TestConvertingToUtf(utfBuffer, 5, originalUnicode, 9, _L8("+BC8-"), _L8(" +BD0ENQ- +BDcEPQQwBE4-."));
sl@0: for (i=6; i<=10; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 8, _L8("+BC8- "), _L8("+BD0ENQ- +BDcEPQQwBE4-."));
sl@0: }
sl@0: for (i=11; i<=13; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 7, _L8("+BC8- +BD0-"), _L8("+BDU- +BDcEPQQwBE4-."));
sl@0: }
sl@0: TestConvertingToUtf(utfBuffer, 14, originalUnicode, 6, _L8("+BC8- +BD0ENQ-"), _L8(" +BDcEPQQwBE4-."));
sl@0: for (i=15; i<=19; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 5, _L8("+BC8- +BD0ENQ- "), _L8("+BDcEPQQwBE4-."));
sl@0: }
sl@0: for (i=20; i<=22; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 4, _L8("+BC8- +BD0ENQ- +BDc-"), _L8("+BD0EMARO-."));
sl@0: }
sl@0: for (i=23; i<=24; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 3, _L8("+BC8- +BD0ENQ- +BDcEPQ-"), _L8("+BDAETg-."));
sl@0: }
sl@0: for (i=25; i<=27; ++i)
sl@0: {
sl@0: TestConvertingToUtf(utfBuffer, i, originalUnicode, 2, _L8("+BC8- +BD0ENQ- +BDcEPQQw-"), _L8("+BE4-."));
sl@0: }
sl@0: TestConvertingToUtf(utfBuffer, 28, originalUnicode, 1, _L8("+BC8- +BD0ENQ- +BDcEPQQwBE4-"), _L8("."));
sl@0: TestConvertingToUtf(utfBuffer, 29, originalUnicode, 0, _L8("+BC8- +BD0ENQ- +BDcEPQQwBE4-."), KNullDesC8);
sl@0: INFO_PRINTF1(_L("Testing converting UCS-2 ending in truncated sequences"));
sl@0: originalUnicode.Format(_L16(" %c"), 0xd800);
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf, originalUnicode, EFalse)==0);
sl@0: test(generatedUtf==_L8(" +2AA-"));
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf, originalUnicode, ETrue)==0);
sl@0: test(generatedUtf==_L8(" +2AA-"));
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf, originalUnicode)==1);
sl@0: test(generatedUtf.Length()==1);
sl@0: test(generatedUtf[0]==' ');
sl@0: originalUnicode.Format(_L16("%c"), 0xd800);
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf, originalUnicode, EFalse)==0);
sl@0: test(generatedUtf==_L8("+2AA-"));
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf, originalUnicode, ETrue)==0);
sl@0: test(generatedUtf==_L8("+2AA-"));
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf, originalUnicode)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: originalUnicode.Format(_L16("%c%c"), 0xd800, 0xdbff);
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf, originalUnicode)==CnvUtfConverter::EErrorIllFormedInput);
sl@0:
sl@0: originalUnicode.Format(_L16("%c%c"), 0xd800, 0xdc00);
sl@0: test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf, originalUnicode)==0);
sl@0: test(generatedUtf==_L8("\xf0\x90\x80\x80"));
sl@0:
sl@0: INFO_PRINTF1(_L("Testing converting UTF-7 ending in truncated sequences"));
sl@0: TInt state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("e+"), state)==1);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]=='e');
sl@0: test(state==CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+-"), state)==0);
sl@0: test(generatedUnicode==_L16("+"));
sl@0: test(state==CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++"), state)==1);
sl@0: test(generatedUnicode.Length()==0);
sl@0: test(state!=CnvUtfConverter::KStateDefault);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+"), state)==CnvUtfConverter::EErrorIllFormedInput); // before resetting state
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++"), state)==2);
sl@0: test(generatedUnicode.Length()==0);
sl@0: test(state!=CnvUtfConverter::KStateDefault);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++"), state)==CnvUtfConverter::EErrorIllFormedInput); // before resetting state
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++"), state)==3);
sl@0: test(generatedUnicode.Length()==0);
sl@0: test(state!=CnvUtfConverter::KStateDefault);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++"), state)==CnvUtfConverter::EErrorIllFormedInput); // before resetting state
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++8"), state)==0);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(state!=CnvUtfConverter::KStateDefault); // this is imporant, as even though we've converted all the input UTF-7, the input may be being received in chunks, in which case, we need to make sure we remember when converting the next chunk that we were previously in a base-64 sequence
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++8-"), state)==0);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(state==CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++/"), state)==1);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(state!=CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++/-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++//"), state)==2);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(state!=CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++//-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///"), state)==3);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(state!=CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++//w"), state)==0);
sl@0: test(generatedUnicode.Length()==2);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(generatedUnicode[1]==0xbfff);
sl@0: test(state!=CnvUtfConverter::KStateDefault); // this is imporant, as even though we've converted all the input UTF-7, the input may be being received in chunks, in which case, we need to make sure we remember when converting the next chunk that we were previously in a base-64 sequence
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++//w-"), state)==0);
sl@0: test(generatedUnicode.Length()==2);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(generatedUnicode[1]==0xbfff);
sl@0: test(state==CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///h"), state)==1);
sl@0: test(generatedUnicode.Length()==2);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(generatedUnicode[1]==0xbfff);
sl@0: test(state!=CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///h-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hh"), state)==0);
sl@0: test(generatedUnicode.Length()==3);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(generatedUnicode[1]==0xbfff);
sl@0: test(generatedUnicode[2]==0xf861);
sl@0: test(state!=CnvUtfConverter::KStateDefault); // this is imporant, as even though we've converted all the input UTF-7, the input may be being received in chunks, in which case, we need to make sure we remember when converting the next chunk that we were previously in a base-64 sequence
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hh-"), state)==0);
sl@0: test(generatedUnicode.Length()==3);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(generatedUnicode[1]==0xbfff);
sl@0: test(generatedUnicode[2]==0xf861);
sl@0: test(state==CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hht"), state)==1);
sl@0: test(generatedUnicode.Length()==3);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(generatedUnicode[1]==0xbfff);
sl@0: test(generatedUnicode[2]==0xf861);
sl@0: test(state!=CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hht-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hhtt"), state)==2);
sl@0: test(generatedUnicode.Length()==3);
sl@0: test(generatedUnicode[0]==0xfbef);
sl@0: test(generatedUnicode[1]==0xbfff);
sl@0: test(generatedUnicode[2]==0xf861);
sl@0: test(state!=CnvUtfConverter::KStateDefault);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hhtt-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: state=CnvUtfConverter::KStateDefault;
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+34-"), state)==CnvUtfConverter::EErrorIllFormedInput);
sl@0: TestUtf7StatePreservation(_L8("++34-"));
sl@0: TestUtf7StatePreservation(_L8("+rY4/5b+al3V98w-"));
sl@0: TestUtf7StatePreservation(_L8("+ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/-"));
sl@0: INFO_PRINTF1(_L("Testing converting UTF-8 ending in truncated sequences"));
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xc8"))==CnvUtfConverter::EErrorIllFormedInput);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("x\xc8"))==1);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]=='x');
sl@0:
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xc8\xc0"))==0);
sl@0: test(generatedUnicode[0]==0xfffd);
sl@0: test(generatedUnicode[1]==0xfffd);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xc8\xb0"))==0);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]==0x0230);
sl@0:
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4"))==CnvUtfConverter::EErrorIllFormedInput);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("y\xe4"))==1);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]=='y');
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4\x80"))==CnvUtfConverter::EErrorIllFormedInput);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("H\xe4\x80"))==2);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]=='H');
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4\xc0"))==CnvUtfConverter::EErrorIllFormedInput);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("e\xe4\xc0"))==2);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]=='e');
sl@0:
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4\x80\xc0"))==0);
sl@0: test(generatedUnicode[0]==0xfffd);
sl@0: test(generatedUnicode[1]==0xfffd);
sl@0: test(generatedUnicode[1]==0xfffd);
sl@0:
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4\x80\xb0"))==0);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]==0x4030);
sl@0:
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2"))==CnvUtfConverter::EErrorIllFormedInput);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("7\xf2"))==1);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]=='7');
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80"))==CnvUtfConverter::EErrorIllFormedInput);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\\\xf2\x80"))==2);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]=='\\');
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\xc0"))==CnvUtfConverter::EErrorIllFormedInput);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("$\xf2\xc0"))==2);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]=='$');
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80\x80"))==CnvUtfConverter::EErrorIllFormedInput);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("{\xf2\x80\x80"))==3);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]=='{');
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80\xc0"))==CnvUtfConverter::EErrorIllFormedInput);
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8(" \xf2\x80\xc0"))==3);
sl@0: test(generatedUnicode.Length()==1);
sl@0: test(generatedUnicode[0]==' ');
sl@0:
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80\x80\xc0"))==0);
sl@0: test(generatedUnicode[0]==0xfffd);
sl@0: test(generatedUnicode[1]==0xfffd);
sl@0: test(generatedUnicode[2]==0xfffd);
sl@0: test(generatedUnicode[3]==0xfffd);
sl@0:
sl@0: test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80\x80\xb0"))==0);
sl@0: test(generatedUnicode.Length()==2);
sl@0: test(generatedUnicode[0]==0xd9c0);
sl@0: test(generatedUnicode[1]==0xdc30);
sl@0: }
sl@0:
sl@0: }
sl@0:
sl@0: CT_PARTIAL::CT_PARTIAL()
sl@0: {
sl@0: SetTestStepName(KTestStep_T_PARTIAL);
sl@0: }
sl@0:
sl@0: TVerdict CT_PARTIAL::doTestStepL()
sl@0: {
sl@0: SetTestStepResult(EFail);
sl@0:
sl@0: __UHEAP_MARK;
sl@0:
sl@0: TRAPD(error1, TestPARTIAL());
sl@0:
sl@0: __UHEAP_MARKEND;
sl@0:
sl@0: if(error1 == KErrNone )
sl@0: {
sl@0: SetTestStepResult(EPass);
sl@0: }
sl@0:
sl@0: return TestStepResult();
sl@0: }