Symaptic: os/textandloc/charconvfw/charconv_fw/test/rtest/tsrc/utf/tpartial.cpp@bde4ae8d615e

     1 /*

     2 * Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    19 #include <e32std.h>

    20 #include <utf.h>

    21 #include "t_partial.h"

    23 #define test(cond)                                          \

    24     {                                                       \

    25     TBool __bb = (cond);                                    \

    26     TEST(__bb);                                             \

    27     if (!__bb)                                              \

    28         {                                                   \

    29         ERR_PRINTF1(_L("ERROR: Test Failed"));              \

    30         User::Leave(1);                                     \

    31         }                                                   \

    32     }

    35 ///////////////////////////////////////////////////////////////////////////////////////

    36 ///////////////////////////////////////////////////////////////////////////////////////

    38 const TInt KUtfBufferLength=100;

    39 const TUint KIllegalUtfByteValue=0xff;

    40 const TUint KIllegalUnicodeCharacter=0xffff;

    42 LOCAL_C void FillWithIllegalUtf(TUint8* aUtfBuffer)

    43 	{

    44 	for (TInt i=0; i<KUtfBufferLength; ++i)

    45 		{

    46 		aUtfBuffer[i]=KIllegalUtfByteValue;

    47 		}

    48 	}

    50 LOCAL_C TBool FillWithIllegalUtfReturningIfMatched(TUint8* aUtfBuffer, const TDes8& aDescriptorAroundBuffer, const TDesC8& aUtfToMatch)

    51 	{

    52 	__ASSERT_ALWAYS(aDescriptorAroundBuffer.Ptr()==aUtfBuffer, User::Panic(_L("TPARTIAL"), 0));

    53 	__ASSERT_ALWAYS(aDescriptorAroundBuffer.MaxLength()>=aUtfToMatch.Length(), User::Panic(_L("TPARTIAL"), 1));

    54 	__ASSERT_ALWAYS(aDescriptorAroundBuffer.MaxLength()<=KUtfBufferLength, User::Panic(_L("TPARTIAL"), 2));

    55 	TBool matched=TPtrC8(aUtfBuffer, aUtfToMatch.Length())==aUtfToMatch;

    56 	if (matched)

    57 		{

    58 		for (TInt i=aDescriptorAroundBuffer.MaxLength(); i<KUtfBufferLength; ++i)

    59 			{

    60 			if (aUtfBuffer[i]!=KIllegalUtfByteValue)

    61 				{

    62 				matched=EFalse;

    63 				break;

    64 				}

    65 			}

    66 		}

    67 	FillWithIllegalUtf(aUtfBuffer);

    68 	return matched;

    69 	}

    71 LOCAL_C void FillWithIllegalUnicode(TUint16* aUnicodeBuffer)

    72 	{

    73 	for (TInt i=0; i<KUtfBufferLength; ++i)

    74 		{

    75 		aUnicodeBuffer[i]=KIllegalUnicodeCharacter;

    76 		}

    77 	}

    79 LOCAL_C TBool FillWithIllegalUnicodeReturningIfMatched(TUint16* aUnicodeBuffer, const TDesC16& aUnicodeToMatch)

    80 	{

    81 	const TInt lengthToMatch=aUnicodeToMatch.Length();

    82 	TBool matched=TPtrC16(aUnicodeBuffer, lengthToMatch)==aUnicodeToMatch;

    83 	if (matched)

    84 		{

    85 		for (TInt i=lengthToMatch; i<KUtfBufferLength; ++i)

    86 			{

    87 			if (aUnicodeBuffer[i]!=KIllegalUnicodeCharacter)

    88 				{

    89 				matched=EFalse;

    90 				break;

    91 				}

    92 			}

    93 		}

    94 	FillWithIllegalUnicode(aUnicodeBuffer);

    95 	return matched;

    96 	}

    97 /**

    98 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0572

    99 @SYMTestCaseDesc        Tests that partial conversions work

   100 @SYMTestPriority        Medium

   101 @SYMTestActions        	Tests for converting to Unicode from UTF- 7

   102 @SYMTestExpectedResults Test must not fail

   103 @SYMREQ                 REQ0000

   104 */

   105 void CT_PARTIAL::TestConvertingToUtf(TUint8* aUtfBuffer, TInt aMaximumLengthOfUtfDescriptor, const TDesC16& aUnicode, TBool aBoolParameter, TInt aNumberOfUnicodeItemsExpectedToBeConverted, const TDesC8& aFirstHalfOfUtfExpected, const TDesC8& aSecondHalfOfUtfExpected)

   106 	{

   107     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0572 "));

   108 	TPtr8 utf(aUtfBuffer, aMaximumLengthOfUtfDescriptor);

   109 	FillWithIllegalUtf(aUtfBuffer);

   110 	test(CnvUtfConverter::ConvertFromUnicodeToUtf7(utf, aUnicode, aBoolParameter)==aNumberOfUnicodeItemsExpectedToBeConverted);

   111 	test(FillWithIllegalUtfReturningIfMatched(aUtfBuffer, utf, aFirstHalfOfUtfExpected));

   112 	TPtr8 restOfUtf(aUtfBuffer, KUtfBufferLength);

   113 	test(CnvUtfConverter::ConvertFromUnicodeToUtf7(restOfUtf, aUnicode.Right(aNumberOfUnicodeItemsExpectedToBeConverted), aBoolParameter)==0);

   114 	test(FillWithIllegalUtfReturningIfMatched(aUtfBuffer, restOfUtf, aSecondHalfOfUtfExpected));

   115 	TBuf8<KUtfBufferLength> originalUtf(aFirstHalfOfUtfExpected);

   116 	originalUtf.Append(aSecondHalfOfUtfExpected);

   117 	TBuf16<20> generatedUnicode;

   118 	TInt state=CnvUtfConverter::KStateDefault;

   119 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, originalUtf, state)==0);

   120 	test(state==CnvUtfConverter::KStateDefault);

   121 	test(generatedUnicode==aUnicode);

   122 	}

   123 /**

   124 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0573

   125 @SYMTestCaseDesc        Tests that partial conversions work

   126 @SYMTestPriority        Medium

   127 @SYMTestActions        	Tests for converting to Unicode from UTF- 7

   128 @SYMTestExpectedResults Test must not fail

   129 @SYMREQ                 REQ0000

   130 */

   131 void CT_PARTIAL::TestUtf7StatePreservation(const TDesC8& aUtf7)

   132 	{

   133     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0573 "));

   134 	TInt state=CnvUtfConverter::KStateDefault;

   135 	TBuf16<50> wholeGeneratedUnicode;

   136 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(wholeGeneratedUnicode, aUtf7, state)==0);

   137 	for (TInt i=aUtf7.Length()-1; i>=0; --i)

   138 		{

   139 		state=CnvUtfConverter::KStateDefault;

   140 		TBuf16<50> generatedUnicode1;

   141 		TInt numberOfUtf7BytesNotConvertedByFirstCall=CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode1, aUtf7.Left(i), state);

   142 		if (numberOfUtf7BytesNotConvertedByFirstCall<0)

   143 			{

   144 			test(numberOfUtf7BytesNotConvertedByFirstCall==CnvUtfConverter::EErrorIllFormedInput);

   145 			numberOfUtf7BytesNotConvertedByFirstCall=i;

   146 			generatedUnicode1=KNullDesC16;

   147 			state=CnvUtfConverter::KStateDefault;

   148 			}

   149 		test(numberOfUtf7BytesNotConvertedByFirstCall>=0);

   150 		TBuf16<50> generatedUnicode2;

   151 		test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode2, aUtf7.Mid(i-numberOfUtf7BytesNotConvertedByFirstCall), state)==0);

   152 		generatedUnicode1+=generatedUnicode2;

   153 		test(generatedUnicode1==wholeGeneratedUnicode);

   154 		}

   155 	}

   157 void CT_PARTIAL::TestConvertingToUtf(TUint8* aUtfBuffer, TInt aMaximumLengthOfUtfDescriptor, const TDesC16& aUnicode, TInt aNumberOfUnicodeItemsExpectedToBeConverted, const TDesC8& aFirstHalfOfUtfExpected, const TDesC8& aSecondHalfOfUtfExpected)

   158 	{

   159 	TestConvertingToUtf(aUtfBuffer, aMaximumLengthOfUtfDescriptor, aUnicode, EFalse, aNumberOfUnicodeItemsExpectedToBeConverted, aFirstHalfOfUtfExpected, aSecondHalfOfUtfExpected);

   160 	}

   162 void CT_PARTIAL::TestPARTIAL()

   163 	{

   164     INFO_PRINTF1(_L("Checking that partial conversions work"));

   165 	TUint8 utfBuffer[KUtfBufferLength];

   166 	TUint16 unicodeBuffer[KUtfBufferLength];

   167 	INFO_PRINTF1(_L("Testing trivial UTF-7 and UTF-8"));

   168 	{

   169 	for (TInt i=0; i<6; ++i)

   170 		{

   171 		const TInt numberOfUnconvertedItemsAtEndOfInputDescriptor=5-i;

   172 		TPtr8 utf(utfBuffer, i);

   173 		FillWithIllegalUtf(utfBuffer);

   174 		test(CnvUtfConverter::ConvertFromUnicodeToUtf7(utf, _L16("abcde"), EFalse)==numberOfUnconvertedItemsAtEndOfInputDescriptor);

   175 		test(FillWithIllegalUtfReturningIfMatched(utfBuffer, utf, _L8("abcde").Left(i)));

   176 		test(CnvUtfConverter::ConvertFromUnicodeToUtf7(utf, _L16("abcde"), ETrue)==numberOfUnconvertedItemsAtEndOfInputDescriptor);

   177 		test(FillWithIllegalUtfReturningIfMatched(utfBuffer, utf, _L8("abcde").Left(i)));

   178 		test(CnvUtfConverter::ConvertFromUnicodeToUtf8(utf, _L16("abcde"))==numberOfUnconvertedItemsAtEndOfInputDescriptor);

   179 		test(FillWithIllegalUtfReturningIfMatched(utfBuffer, utf, _L8("abcde").Left(i)));

   180 		TPtr16 unicode(unicodeBuffer, i);

   181 		TInt state=CnvUtfConverter::KStateDefault;

   182 		FillWithIllegalUnicode(unicodeBuffer);

   183 		test(CnvUtfConverter::ConvertToUnicodeFromUtf7(unicode, _L8("abcde"), state)==numberOfUnconvertedItemsAtEndOfInputDescriptor);

   184 		test(FillWithIllegalUnicodeReturningIfMatched(unicodeBuffer, _L16("abcde").Left(i)));

   185 		test(state==CnvUtfConverter::KStateDefault);

   186 		test(CnvUtfConverter::ConvertToUnicodeFromUtf8(unicode, _L8("abcde"))==numberOfUnconvertedItemsAtEndOfInputDescriptor);

   187 		test(FillWithIllegalUnicodeReturningIfMatched(unicodeBuffer, _L16("abcde").Left(i)));

   188 		}

   189 	}

   190 	INFO_PRINTF1(_L("Testing converting to UTF-7"));

   191 	{

   192 	TBuf16<20> originalUnicode;

   193 	TBuf16<20> generatedUnicode;

   194 	TBuf8<20> generatedUtf;

   195 	originalUnicode.Format(_L16("%c%c%c%c?"), 0x8fd9, 0x662f, 0x4ec0, 0x4e48); // Chinese: zhe4 shi4 shen2 me?

   196 	TInt i;

   197 	for (i=0; i<=4; ++i)

   198 		{

   199 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 5, KNullDesC8, _L8("+j9lmL07ATkg-?"));

   200 		}

   201 	for (i=5; i<=7; ++i)

   202 		{

   203 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 4, _L8("+j9k-"), _L8("+Zi9OwE5I-?"));

   204 		}

   205 	for (i=8; i<=9; ++i)

   206 		{

   207 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 3, _L8("+j9lmLw-"), _L8("+TsBOSA-?"));

   208 		}

   209 	for (i=10; i<=12; ++i)

   210 		{

   211 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 2, _L8("+j9lmL07A-"), _L8("+Tkg-?"));

   212 		}

   213 	TestConvertingToUtf(utfBuffer, 13, originalUnicode, 1, _L8("+j9lmL07ATkg-"), _L8("?"));

   214 	TestConvertingToUtf(utfBuffer, 14, originalUnicode, 0, _L8("+j9lmL07ATkg-?"), KNullDesC8);

   215 	originalUnicode.Format(_L16("%c %c%c %c%c%c%c."), 0x042f, 0x043d, 0x0435, 0x0437, 0x043d, 0x0430, 0x044e); // Russian: ya nye znayu.

   216 	for (i=0; i<=4; ++i)

   217 		{

   218 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 10, KNullDesC8, _L8("+BC8- +BD0ENQ- +BDcEPQQwBE4-."));

   219 		}

   220 	TestConvertingToUtf(utfBuffer, 5, originalUnicode, 9, _L8("+BC8-"), _L8(" +BD0ENQ- +BDcEPQQwBE4-."));

   221 	for (i=6; i<=10; ++i)

   222 		{

   223 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 8, _L8("+BC8- "), _L8("+BD0ENQ- +BDcEPQQwBE4-."));

   224 		}

   225 	for (i=11; i<=13; ++i)

   226 		{

   227 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 7, _L8("+BC8- +BD0-"), _L8("+BDU- +BDcEPQQwBE4-."));

   228 		}

   229 	TestConvertingToUtf(utfBuffer, 14, originalUnicode, 6, _L8("+BC8- +BD0ENQ-"), _L8(" +BDcEPQQwBE4-."));

   230 	for (i=15; i<=19; ++i)

   231 		{

   232 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 5, _L8("+BC8- +BD0ENQ- "), _L8("+BDcEPQQwBE4-."));

   233 		}

   234 	for (i=20; i<=22; ++i)

   235 		{

   236 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 4, _L8("+BC8- +BD0ENQ- +BDc-"), _L8("+BD0EMARO-."));

   237 		}

   238 	for (i=23; i<=24; ++i)

   239 		{

   240 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 3, _L8("+BC8- +BD0ENQ- +BDcEPQ-"), _L8("+BDAETg-."));

   241 		}

   242 	for (i=25; i<=27; ++i)

   243 		{

   244 		TestConvertingToUtf(utfBuffer, i, originalUnicode, 2, _L8("+BC8- +BD0ENQ- +BDcEPQQw-"), _L8("+BE4-."));

   245 		}

   246 	TestConvertingToUtf(utfBuffer, 28, originalUnicode, 1, _L8("+BC8- +BD0ENQ- +BDcEPQQwBE4-"), _L8("."));

   247 	TestConvertingToUtf(utfBuffer, 29, originalUnicode, 0, _L8("+BC8- +BD0ENQ- +BDcEPQQwBE4-."), KNullDesC8);

   248 	INFO_PRINTF1(_L("Testing converting UCS-2 ending in truncated sequences"));

   249 	originalUnicode.Format(_L16(" %c"), 0xd800);

   250 	test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf, originalUnicode, EFalse)==0);

   251 	test(generatedUtf==_L8(" +2AA-"));

   252 	test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf, originalUnicode, ETrue)==0);

   253 	test(generatedUtf==_L8(" +2AA-"));

   254 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf, originalUnicode)==1);

   255 	test(generatedUtf.Length()==1);

   256 	test(generatedUtf[0]==' ');

   257 	originalUnicode.Format(_L16("%c"), 0xd800);

   258 	test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf, originalUnicode, EFalse)==0);

   259 	test(generatedUtf==_L8("+2AA-"));

   260 	test(CnvUtfConverter::ConvertFromUnicodeToUtf7(generatedUtf, originalUnicode, ETrue)==0);

   261 	test(generatedUtf==_L8("+2AA-"));

   262 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf, originalUnicode)==CnvUtfConverter::EErrorIllFormedInput);

   263 	originalUnicode.Format(_L16("%c%c"), 0xd800, 0xdbff);

   264 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf, originalUnicode)==CnvUtfConverter::EErrorIllFormedInput);

   266 	originalUnicode.Format(_L16("%c%c"), 0xd800, 0xdc00);

   267 	test(CnvUtfConverter::ConvertFromUnicodeToUtf8(generatedUtf, originalUnicode)==0);

   268 	test(generatedUtf==_L8("\xf0\x90\x80\x80"));

   270 	INFO_PRINTF1(_L("Testing converting UTF-7 ending in truncated sequences"));

   271 	TInt state=CnvUtfConverter::KStateDefault;

   272 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+"), state)==CnvUtfConverter::EErrorIllFormedInput);

   273 	state=CnvUtfConverter::KStateDefault;

   274 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("e+"), state)==1);

   275 	test(generatedUnicode.Length()==1);

   276 	test(generatedUnicode[0]=='e');

   277 	test(state==CnvUtfConverter::KStateDefault);

   278 	state=CnvUtfConverter::KStateDefault;

   279 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+-"), state)==0);

   280 	test(generatedUnicode==_L16("+"));

   281 	test(state==CnvUtfConverter::KStateDefault);

   282 	state=CnvUtfConverter::KStateDefault;

   283 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++"), state)==1);

   284 	test(generatedUnicode.Length()==0);

   285 	test(state!=CnvUtfConverter::KStateDefault);

   286 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+"), state)==CnvUtfConverter::EErrorIllFormedInput); // before resetting state

   287 	state=CnvUtfConverter::KStateDefault;

   288 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   289 	state=CnvUtfConverter::KStateDefault;

   290 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++"), state)==2);

   291 	test(generatedUnicode.Length()==0);

   292 	test(state!=CnvUtfConverter::KStateDefault);

   293 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++"), state)==CnvUtfConverter::EErrorIllFormedInput); // before resetting state

   294 	state=CnvUtfConverter::KStateDefault;

   295 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   296 	state=CnvUtfConverter::KStateDefault;

   297 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++"), state)==3);

   298 	test(generatedUnicode.Length()==0);

   299 	test(state!=CnvUtfConverter::KStateDefault);

   300 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++"), state)==CnvUtfConverter::EErrorIllFormedInput); // before resetting state

   301 	state=CnvUtfConverter::KStateDefault;

   302 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   303 	state=CnvUtfConverter::KStateDefault;

   304 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++8"), state)==0);

   305 	test(generatedUnicode.Length()==1);

   306 	test(generatedUnicode[0]==0xfbef);

   307 	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

   308 	state=CnvUtfConverter::KStateDefault;

   309 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+++8-"), state)==0);

   310 	test(generatedUnicode.Length()==1);

   311 	test(generatedUnicode[0]==0xfbef);

   312 	test(state==CnvUtfConverter::KStateDefault);

   313 	state=CnvUtfConverter::KStateDefault;

   314 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++/"), state)==1);

   315 	test(generatedUnicode.Length()==1);

   316 	test(generatedUnicode[0]==0xfbef);

   317 	test(state!=CnvUtfConverter::KStateDefault);

   318 	state=CnvUtfConverter::KStateDefault;

   319 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++/-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   320 	state=CnvUtfConverter::KStateDefault;

   321 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++//"), state)==2);

   322 	test(generatedUnicode.Length()==1);

   323 	test(generatedUnicode[0]==0xfbef);

   324 	test(state!=CnvUtfConverter::KStateDefault);

   325 	state=CnvUtfConverter::KStateDefault;

   326 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++//-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   327 	state=CnvUtfConverter::KStateDefault;

   328 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///"), state)==3);

   329 	test(generatedUnicode.Length()==1);

   330 	test(generatedUnicode[0]==0xfbef);

   331 	test(state!=CnvUtfConverter::KStateDefault);

   332 	state=CnvUtfConverter::KStateDefault;

   333 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   334 	state=CnvUtfConverter::KStateDefault;

   335 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++//w"), state)==0);

   336 	test(generatedUnicode.Length()==2);

   337 	test(generatedUnicode[0]==0xfbef);

   338 	test(generatedUnicode[1]==0xbfff);

   339 	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

   340 	state=CnvUtfConverter::KStateDefault;

   341 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++//w-"), state)==0);

   342 	test(generatedUnicode.Length()==2);

   343 	test(generatedUnicode[0]==0xfbef);

   344 	test(generatedUnicode[1]==0xbfff);

   345 	test(state==CnvUtfConverter::KStateDefault);

   346 	state=CnvUtfConverter::KStateDefault;

   347 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///h"), state)==1);

   348 	test(generatedUnicode.Length()==2);

   349 	test(generatedUnicode[0]==0xfbef);

   350 	test(generatedUnicode[1]==0xbfff);

   351 	test(state!=CnvUtfConverter::KStateDefault);

   352 	state=CnvUtfConverter::KStateDefault;

   353 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///h-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   354 	state=CnvUtfConverter::KStateDefault;

   355 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hh"), state)==0);

   356 	test(generatedUnicode.Length()==3);

   357 	test(generatedUnicode[0]==0xfbef);

   358 	test(generatedUnicode[1]==0xbfff);

   359 	test(generatedUnicode[2]==0xf861);

   360 	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

   361 	state=CnvUtfConverter::KStateDefault;

   362 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hh-"), state)==0);

   363 	test(generatedUnicode.Length()==3);

   364 	test(generatedUnicode[0]==0xfbef);

   365 	test(generatedUnicode[1]==0xbfff);

   366 	test(generatedUnicode[2]==0xf861);

   367 	test(state==CnvUtfConverter::KStateDefault);

   368 	state=CnvUtfConverter::KStateDefault;

   369 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hht"), state)==1);

   370 	test(generatedUnicode.Length()==3);

   371 	test(generatedUnicode[0]==0xfbef);

   372 	test(generatedUnicode[1]==0xbfff);

   373 	test(generatedUnicode[2]==0xf861);

   374 	test(state!=CnvUtfConverter::KStateDefault);

   375 	state=CnvUtfConverter::KStateDefault;

   376 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hht-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   377 	state=CnvUtfConverter::KStateDefault;

   378 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hhtt"), state)==2);

   379 	test(generatedUnicode.Length()==3);

   380 	test(generatedUnicode[0]==0xfbef);

   381 	test(generatedUnicode[1]==0xbfff);

   382 	test(generatedUnicode[2]==0xf861);

   383 	test(state!=CnvUtfConverter::KStateDefault);

   384 	state=CnvUtfConverter::KStateDefault;

   385 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("++++///hhtt-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   386 	state=CnvUtfConverter::KStateDefault;

   387 	test(CnvUtfConverter::ConvertToUnicodeFromUtf7(generatedUnicode, _L8("+34-"), state)==CnvUtfConverter::EErrorIllFormedInput);

   388 	TestUtf7StatePreservation(_L8("++34-"));

   389 	TestUtf7StatePreservation(_L8("+rY4/5b+al3V98w-"));

   390 	TestUtf7StatePreservation(_L8("+ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/-"));

   391 	INFO_PRINTF1(_L("Testing converting UTF-8 ending in truncated sequences"));

   392 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xc8"))==CnvUtfConverter::EErrorIllFormedInput);

   393 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("x\xc8"))==1);

   394 	test(generatedUnicode.Length()==1);

   395  	test(generatedUnicode[0]=='x');

   397  	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xc8\xc0"))==0);

   398 	test(generatedUnicode[0]==0xfffd);

   399 	test(generatedUnicode[1]==0xfffd);

   400 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xc8\xb0"))==0);

   401 	test(generatedUnicode.Length()==1);

   402 	test(generatedUnicode[0]==0x0230);

   404 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4"))==CnvUtfConverter::EErrorIllFormedInput);

   405 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("y\xe4"))==1);

   406 	test(generatedUnicode.Length()==1);

   407 	test(generatedUnicode[0]=='y');

   408 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4\x80"))==CnvUtfConverter::EErrorIllFormedInput);

   409 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("H\xe4\x80"))==2);

   410 	test(generatedUnicode.Length()==1);

   411 	test(generatedUnicode[0]=='H');

   412 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4\xc0"))==CnvUtfConverter::EErrorIllFormedInput);

   413 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("e\xe4\xc0"))==2);

   414 	test(generatedUnicode.Length()==1);

   415 	test(generatedUnicode[0]=='e');

   417 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4\x80\xc0"))==0);

   418 	test(generatedUnicode[0]==0xfffd);

   419 	test(generatedUnicode[1]==0xfffd);

   420 	test(generatedUnicode[1]==0xfffd);

   422 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xe4\x80\xb0"))==0);

   423 	test(generatedUnicode.Length()==1);

   424 	test(generatedUnicode[0]==0x4030);

   426 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2"))==CnvUtfConverter::EErrorIllFormedInput);

   427 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("7\xf2"))==1);

   428 	test(generatedUnicode.Length()==1);

   429 	test(generatedUnicode[0]=='7');

   430 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80"))==CnvUtfConverter::EErrorIllFormedInput);

   431 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\\\xf2\x80"))==2);

   432 	test(generatedUnicode.Length()==1);

   433 	test(generatedUnicode[0]=='\\');

   434 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\xc0"))==CnvUtfConverter::EErrorIllFormedInput);

   435 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("$\xf2\xc0"))==2);

   436 	test(generatedUnicode.Length()==1);

   437 	test(generatedUnicode[0]=='$');

   438 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80\x80"))==CnvUtfConverter::EErrorIllFormedInput);

   439 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("{\xf2\x80\x80"))==3);

   440 	test(generatedUnicode.Length()==1);

   441 	test(generatedUnicode[0]=='{');

   442 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80\xc0"))==CnvUtfConverter::EErrorIllFormedInput);

   443 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8(" \xf2\x80\xc0"))==3);

   444 	test(generatedUnicode.Length()==1);

   445 	test(generatedUnicode[0]==' ');

   447  	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80\x80\xc0"))==0);

   448 	test(generatedUnicode[0]==0xfffd);

   449 	test(generatedUnicode[1]==0xfffd);

   450 	test(generatedUnicode[2]==0xfffd);

   451 	test(generatedUnicode[3]==0xfffd);

   453 	test(CnvUtfConverter::ConvertToUnicodeFromUtf8(generatedUnicode, _L8("\xf2\x80\x80\xb0"))==0);

   454 	test(generatedUnicode.Length()==2);

   455 	test(generatedUnicode[0]==0xd9c0);

   456 	test(generatedUnicode[1]==0xdc30);

   457 	}

   459 	}

   461 CT_PARTIAL::CT_PARTIAL()

   462     {

   463     SetTestStepName(KTestStep_T_PARTIAL);

   464     }

   466 TVerdict CT_PARTIAL::doTestStepL()

   467     {

   468     SetTestStepResult(EFail);

   470     __UHEAP_MARK;

   472     TRAPD(error1, TestPARTIAL());

   474     __UHEAP_MARKEND;

   476     if(error1 == KErrNone )

   477         {

   478         SetTestStepResult(EPass);

   479         }

   481     return TestStepResult();

   482     }

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--